nestlens 0.1.0

package/dist/__tests__/filters/storage-filters.spec.js

@@ -0,0 +1,699 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const test_utils_1 = require("./test-utils");
+const entry_factories_1 = require("./entry-factories");
+describe('Storage Filters', () => {
+    let storage;
+    beforeEach(() => {
+        storage = (0, test_utils_1.createTestStorage)();
+    });
+    afterEach(async () => {
+        await storage.close();
+    });
+    // ==================== LOG FILTERS ====================
+    describe('Log Filters', () => {
+        describe('levels', () => {
+            it('returns only entries matching specified log levels', async () => {
+                const entries = [
+                    (0, entry_factories_1.createLogEntry)({ level: 'error', message: 'Error 1' }),
+                    (0, entry_factories_1.createLogEntry)({ level: 'warn', message: 'Warning 1' }),
+                    (0, entry_factories_1.createLogEntry)({ level: 'debug', message: 'Debug 1' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('log', {
+                    filters: { levels: ['error', 'warn'] },
+                });
+                expect(result.data).toHaveLength(2);
+                expect(result.data.every((e) => ['error', 'warn'].includes(e.payload.level))).toBe(true);
+            });
+            it('excludes non-matching entries', async () => {
+                await (0, test_utils_1.seedStorage)(storage, [
+                    (0, entry_factories_1.createLogEntry)({ level: 'debug' }),
+                    (0, entry_factories_1.createLogEntry)({ level: 'verbose' }),
+                ]);
+                const result = await storage.findWithCursor('log', {
+                    filters: { levels: ['error'] },
+                });
+                expect(result.data).toHaveLength(0);
+            });
+        });
+        describe('contexts', () => {
+            it('returns only entries matching specified contexts', async () => {
+                const entries = [
+                    (0, entry_factories_1.createLogEntry)({ context: 'UserService' }),
+                    (0, entry_factories_1.createLogEntry)({ context: 'AuthController' }),
+                    (0, entry_factories_1.createLogEntry)({ context: 'CacheModule' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('log', {
+                    filters: { contexts: ['UserService', 'AuthController'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== QUERY FILTERS ====================
+    describe('Query Filters', () => {
+        describe('queryTypes', () => {
+            it('filters queries by SQL type prefix', async () => {
+                const entries = [
+                    (0, entry_factories_1.createQueryEntry)({ query: 'SELECT * FROM users' }),
+                    (0, entry_factories_1.createQueryEntry)({ query: 'SELECT id FROM orders' }),
+                    (0, entry_factories_1.createQueryEntry)({ query: 'INSERT INTO users VALUES(1)' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('query', {
+                    filters: { queryTypes: ['SELECT'] },
+                });
+                expect(result.data).toHaveLength(2);
+                expect(result.data.every((e) => e.payload.query.startsWith('SELECT'))).toBe(true);
+            });
+        });
+        describe('sources', () => {
+            it('filters queries by ORM source', async () => {
+                const entries = [
+                    (0, entry_factories_1.createQueryEntry)({ source: 'typeorm' }),
+                    (0, entry_factories_1.createQueryEntry)({ source: 'prisma' }),
+                    (0, entry_factories_1.createQueryEntry)({ source: 'typeorm' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('query', {
+                    filters: { sources: ['typeorm'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('slow', () => {
+            it('filters slow queries', async () => {
+                const entries = [
+                    (0, entry_factories_1.createQueryEntry)({ slow: true }),
+                    (0, entry_factories_1.createQueryEntry)({ slow: false }),
+                    (0, entry_factories_1.createQueryEntry)({ slow: true }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('query', {
+                    filters: { slow: true },
+                });
+                expect(result.data).toHaveLength(2);
+                expect(result.data.every((e) => e.payload.slow === true)).toBe(true);
+            });
+        });
+    });
+    // ==================== EXCEPTION FILTERS ====================
+    describe('Exception Filters', () => {
+        describe('names', () => {
+            it('filters exceptions by name with LIKE pattern', async () => {
+                const entries = [
+                    (0, entry_factories_1.createExceptionEntry)({ name: 'TypeError' }),
+                    (0, entry_factories_1.createExceptionEntry)({ name: 'TypeError: Cannot read property' }),
+                    (0, entry_factories_1.createExceptionEntry)({ name: 'ReferenceError' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('exception', {
+                    filters: { names: ['TypeError'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== REQUEST FILTERS ====================
+    describe('Request Filters', () => {
+        describe('methods', () => {
+            it('filters requests by HTTP method', async () => {
+                const entries = [
+                    (0, entry_factories_1.createRequestEntry)({ method: 'GET' }),
+                    (0, entry_factories_1.createRequestEntry)({ method: 'POST' }),
+                    (0, entry_factories_1.createRequestEntry)({ method: 'DELETE' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('request', {
+                    filters: { methods: ['GET', 'POST'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('paths', () => {
+            it('filters requests by path with LIKE pattern', async () => {
+                const entries = [
+                    (0, entry_factories_1.createRequestEntry)({ path: '/api/users' }),
+                    (0, entry_factories_1.createRequestEntry)({ path: '/api/users/1' }),
+                    (0, entry_factories_1.createRequestEntry)({ path: '/api/orders' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('request', {
+                    filters: { paths: ['/api/users'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('statuses', () => {
+            it('filters requests by status code', async () => {
+                const entries = [
+                    (0, entry_factories_1.createRequestEntry)({ statusCode: 200 }),
+                    (0, entry_factories_1.createRequestEntry)({ statusCode: 201 }),
+                    (0, entry_factories_1.createRequestEntry)({ statusCode: 404 }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('request', {
+                    filters: { statuses: [200, 201] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+            it('handles ERR status for entries without status code', async () => {
+                const entries = [
+                    (0, entry_factories_1.createRequestEntry)({ statusCode: 200 }),
+                    (0, entry_factories_1.createRequestEntry)({ statusCode: undefined }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('request', {
+                    filters: { statuses: ['ERR'] },
+                });
+                expect(result.data).toHaveLength(1);
+            });
+        });
+        describe('hostnames', () => {
+            it('filters requests by hostname', async () => {
+                const entries = [
+                    (0, entry_factories_1.createRequestEntry)({ headers: { host: 'localhost:3000' } }),
+                    (0, entry_factories_1.createRequestEntry)({ headers: { host: 'api.example.com' } }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('request', {
+                    filters: { hostnames: ['localhost'] },
+                });
+                expect(result.data).toHaveLength(1);
+            });
+        });
+        describe('controllers', () => {
+            it('filters requests by controller action', async () => {
+                const entries = [
+                    (0, entry_factories_1.createRequestEntry)({ controllerAction: 'UsersController#findAll' }),
+                    (0, entry_factories_1.createRequestEntry)({ controllerAction: 'UsersController#create' }),
+                    (0, entry_factories_1.createRequestEntry)({ controllerAction: 'OrdersController#list' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('request', {
+                    filters: { controllers: ['UsersController#findAll', 'UsersController#create'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('ips', () => {
+            it('filters requests by IP address', async () => {
+                const entries = [
+                    (0, entry_factories_1.createRequestEntry)({ ip: '127.0.0.1' }),
+                    (0, entry_factories_1.createRequestEntry)({ ip: '::1' }),
+                    (0, entry_factories_1.createRequestEntry)({ ip: '192.168.1.1' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('request', {
+                    filters: { ips: ['127.0.0.1', '::1'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== HTTP CLIENT FILTERS ====================
+    describe('HTTP Client Filters', () => {
+        describe('methods', () => {
+            it('filters http client entries by method', async () => {
+                const entries = [
+                    (0, entry_factories_1.createHttpClientEntry)({ method: 'GET' }),
+                    (0, entry_factories_1.createHttpClientEntry)({ method: 'POST' }),
+                    (0, entry_factories_1.createHttpClientEntry)({ method: 'DELETE' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('http-client', {
+                    filters: { methods: ['GET', 'POST'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('statuses', () => {
+            it('filters http client entries by status code', async () => {
+                const entries = [
+                    (0, entry_factories_1.createHttpClientEntry)({ statusCode: 200 }),
+                    (0, entry_factories_1.createHttpClientEntry)({ statusCode: 404 }),
+                    (0, entry_factories_1.createHttpClientEntry)({ statusCode: 500 }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('http-client', {
+                    filters: { statuses: [200, 404] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('hostnames', () => {
+            it('filters http client entries by hostname', async () => {
+                const entries = [
+                    (0, entry_factories_1.createHttpClientEntry)({ hostname: 'api.example.com' }),
+                    (0, entry_factories_1.createHttpClientEntry)({ hostname: 'cdn.example.com' }),
+                    (0, entry_factories_1.createHttpClientEntry)({ hostname: 'auth.different.com' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('http-client', {
+                    filters: { hostnames: ['example'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== EVENT FILTERS ====================
+    describe('Event Filters', () => {
+        describe('names', () => {
+            it('filters events by name with LIKE pattern', async () => {
+                const entries = [
+                    (0, entry_factories_1.createEventEntry)({ name: 'user.created' }),
+                    (0, entry_factories_1.createEventEntry)({ name: 'user.updated' }),
+                    (0, entry_factories_1.createEventEntry)({ name: 'order.placed' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('event', {
+                    filters: { names: ['user'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== JOB FILTERS ====================
+    describe('Job Filters', () => {
+        describe('jobStatuses', () => {
+            it('filters jobs by status', async () => {
+                const entries = [
+                    (0, entry_factories_1.createJobEntry)({ status: 'completed' }),
+                    (0, entry_factories_1.createJobEntry)({ status: 'active' }),
+                    (0, entry_factories_1.createJobEntry)({ status: 'failed' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('job', {
+                    filters: { jobStatuses: ['completed', 'active'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('queues', () => {
+            it('filters jobs by queue name', async () => {
+                const entries = [
+                    (0, entry_factories_1.createJobEntry)({ queue: 'default' }),
+                    (0, entry_factories_1.createJobEntry)({ queue: 'emails' }),
+                    (0, entry_factories_1.createJobEntry)({ queue: 'notifications' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('job', {
+                    filters: { queues: ['default', 'emails'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('names', () => {
+            it('filters jobs by name with LIKE pattern', async () => {
+                const entries = [
+                    (0, entry_factories_1.createJobEntry)({ name: 'send-email' }),
+                    (0, entry_factories_1.createJobEntry)({ name: 'send-notification' }),
+                    (0, entry_factories_1.createJobEntry)({ name: 'process-order' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('job', {
+                    filters: { names: ['send'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== SCHEDULE FILTERS ====================
+    describe('Schedule Filters', () => {
+        describe('scheduleStatuses', () => {
+            it('filters scheduled tasks by status', async () => {
+                const entries = [
+                    (0, entry_factories_1.createScheduleEntry)({ status: 'completed' }),
+                    (0, entry_factories_1.createScheduleEntry)({ status: 'started' }),
+                    (0, entry_factories_1.createScheduleEntry)({ status: 'failed' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('schedule', {
+                    filters: { scheduleStatuses: ['completed'] },
+                });
+                expect(result.data).toHaveLength(1);
+            });
+        });
+        describe('names', () => {
+            it('filters scheduled tasks by name with LIKE pattern', async () => {
+                const entries = [
+                    (0, entry_factories_1.createScheduleEntry)({ name: 'cleanup-task' }),
+                    (0, entry_factories_1.createScheduleEntry)({ name: 'cleanup-logs' }),
+                    (0, entry_factories_1.createScheduleEntry)({ name: 'send-reports' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('schedule', {
+                    filters: { names: ['cleanup'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== CACHE FILTERS ====================
+    describe('Cache Filters', () => {
+        describe('cacheOperations', () => {
+            it('filters cache entries by operation', async () => {
+                const entries = [
+                    (0, entry_factories_1.createCacheEntry)({ operation: 'get' }),
+                    (0, entry_factories_1.createCacheEntry)({ operation: 'set' }),
+                    (0, entry_factories_1.createCacheEntry)({ operation: 'del' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('cache', {
+                    filters: { cacheOperations: ['get', 'set'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== MAIL FILTERS ====================
+    describe('Mail Filters', () => {
+        describe('mailStatuses', () => {
+            it('filters mail entries by status', async () => {
+                const entries = [
+                    (0, entry_factories_1.createMailEntry)({ status: 'sent' }),
+                    (0, entry_factories_1.createMailEntry)({ status: 'failed' }),
+                    (0, entry_factories_1.createMailEntry)({ status: 'sent' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('mail', {
+                    filters: { mailStatuses: ['sent'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== REDIS FILTERS ====================
+    describe('Redis Filters', () => {
+        describe('redisStatuses', () => {
+            it('filters redis entries by status', async () => {
+                const entries = [
+                    (0, entry_factories_1.createRedisEntry)({ status: 'success' }),
+                    (0, entry_factories_1.createRedisEntry)({ status: 'error' }),
+                    (0, entry_factories_1.createRedisEntry)({ status: 'success' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('redis', {
+                    filters: { redisStatuses: ['success'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('redisCommands', () => {
+            it('filters redis entries by command', async () => {
+                const entries = [
+                    (0, entry_factories_1.createRedisEntry)({ command: 'GET' }),
+                    (0, entry_factories_1.createRedisEntry)({ command: 'SET' }),
+                    (0, entry_factories_1.createRedisEntry)({ command: 'HGET' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('redis', {
+                    filters: { redisCommands: ['GET', 'SET'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== MODEL FILTERS ====================
+    describe('Model Filters', () => {
+        describe('modelActions', () => {
+            it('filters model entries by action', async () => {
+                const entries = [
+                    (0, entry_factories_1.createModelEntry)({ action: 'create' }),
+                    (0, entry_factories_1.createModelEntry)({ action: 'update' }),
+                    (0, entry_factories_1.createModelEntry)({ action: 'find' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('model', {
+                    filters: { modelActions: ['create', 'update'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('entities', () => {
+            it('filters model entries by entity name', async () => {
+                const entries = [
+                    (0, entry_factories_1.createModelEntry)({ entity: 'User' }),
+                    (0, entry_factories_1.createModelEntry)({ entity: 'Post' }),
+                    (0, entry_factories_1.createModelEntry)({ entity: 'Comment' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('model', {
+                    filters: { entities: ['User', 'Post'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('modelSources', () => {
+            it('filters model entries by ORM source', async () => {
+                const entries = [
+                    (0, entry_factories_1.createModelEntry)({ source: 'typeorm' }),
+                    (0, entry_factories_1.createModelEntry)({ source: 'prisma' }),
+                    (0, entry_factories_1.createModelEntry)({ source: 'typeorm' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('model', {
+                    filters: { modelSources: ['typeorm'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== NOTIFICATION FILTERS ====================
+    describe('Notification Filters', () => {
+        describe('notificationTypes', () => {
+            it('filters notifications by type', async () => {
+                const entries = [
+                    (0, entry_factories_1.createNotificationEntry)({ type: 'email' }),
+                    (0, entry_factories_1.createNotificationEntry)({ type: 'sms' }),
+                    (0, entry_factories_1.createNotificationEntry)({ type: 'push' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('notification', {
+                    filters: { notificationTypes: ['email', 'sms'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('notificationStatuses', () => {
+            it('filters notifications by status', async () => {
+                const entries = [
+                    (0, entry_factories_1.createNotificationEntry)({ status: 'sent' }),
+                    (0, entry_factories_1.createNotificationEntry)({ status: 'failed' }),
+                    (0, entry_factories_1.createNotificationEntry)({ status: 'sent' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('notification', {
+                    filters: { notificationStatuses: ['sent'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== VIEW FILTERS ====================
+    describe('View Filters', () => {
+        describe('viewFormats', () => {
+            it('filters views by format', async () => {
+                const entries = [
+                    (0, entry_factories_1.createViewEntry)({ format: 'html' }),
+                    (0, entry_factories_1.createViewEntry)({ format: 'json' }),
+                    (0, entry_factories_1.createViewEntry)({ format: 'xml' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('view', {
+                    filters: { viewFormats: ['html', 'json'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('viewStatuses', () => {
+            it('filters views by status', async () => {
+                const entries = [
+                    (0, entry_factories_1.createViewEntry)({ status: 'rendered' }),
+                    (0, entry_factories_1.createViewEntry)({ status: 'error' }),
+                    (0, entry_factories_1.createViewEntry)({ status: 'rendered' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('view', {
+                    filters: { viewStatuses: ['rendered'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== COMMAND FILTERS ====================
+    describe('Command Filters', () => {
+        describe('commandStatuses', () => {
+            it('filters commands by status', async () => {
+                const entries = [
+                    (0, entry_factories_1.createCommandEntry)({ status: 'completed' }),
+                    (0, entry_factories_1.createCommandEntry)({ status: 'executing' }),
+                    (0, entry_factories_1.createCommandEntry)({ status: 'failed' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('command', {
+                    filters: { commandStatuses: ['completed'] },
+                });
+                expect(result.data).toHaveLength(1);
+            });
+        });
+        describe('commandNames', () => {
+            it('filters commands by name with LIKE pattern', async () => {
+                const entries = [
+                    (0, entry_factories_1.createCommandEntry)({ name: 'cache:clear' }),
+                    (0, entry_factories_1.createCommandEntry)({ name: 'cache:warmup' }),
+                    (0, entry_factories_1.createCommandEntry)({ name: 'db:migrate' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('command', {
+                    filters: { commandNames: ['cache'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== GATE FILTERS ====================
+    describe('Gate Filters', () => {
+        describe('gateNames', () => {
+            it('filters gates by name with LIKE pattern', async () => {
+                const entries = [
+                    (0, entry_factories_1.createGateEntry)({ gate: 'admin' }),
+                    (0, entry_factories_1.createGateEntry)({ gate: 'admin-panel' }),
+                    (0, entry_factories_1.createGateEntry)({ gate: 'premium' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('gate', {
+                    filters: { gateNames: ['admin'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('gateResults', () => {
+            it('filters gates by result (allowed)', async () => {
+                const entries = [
+                    (0, entry_factories_1.createGateEntry)({ allowed: true }),
+                    (0, entry_factories_1.createGateEntry)({ allowed: false }),
+                    (0, entry_factories_1.createGateEntry)({ allowed: true }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('gate', {
+                    filters: { gateResults: ['allowed'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+            it('filters gates by result (denied)', async () => {
+                const entries = [
+                    (0, entry_factories_1.createGateEntry)({ allowed: true }),
+                    (0, entry_factories_1.createGateEntry)({ allowed: false }),
+                    (0, entry_factories_1.createGateEntry)({ allowed: false }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('gate', {
+                    filters: { gateResults: ['denied'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== BATCH FILTERS ====================
+    describe('Batch Filters', () => {
+        describe('batchStatuses', () => {
+            it('filters batches by status', async () => {
+                const entries = [
+                    (0, entry_factories_1.createBatchEntry)({ status: 'completed' }),
+                    (0, entry_factories_1.createBatchEntry)({ status: 'partial' }),
+                    (0, entry_factories_1.createBatchEntry)({ status: 'failed' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('batch', {
+                    filters: { batchStatuses: ['completed'] },
+                });
+                expect(result.data).toHaveLength(1);
+            });
+        });
+        describe('batchOperations', () => {
+            it('filters batches by operation', async () => {
+                const entries = [
+                    (0, entry_factories_1.createBatchEntry)({ operation: 'insert' }),
+                    (0, entry_factories_1.createBatchEntry)({ operation: 'update' }),
+                    (0, entry_factories_1.createBatchEntry)({ operation: 'delete' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('batch', {
+                    filters: { batchOperations: ['insert', 'update'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== DUMP FILTERS ====================
+    describe('Dump Filters', () => {
+        describe('dumpStatuses', () => {
+            it('filters dumps by status', async () => {
+                const entries = [
+                    (0, entry_factories_1.createDumpEntry)({ status: 'completed' }),
+                    (0, entry_factories_1.createDumpEntry)({ status: 'failed' }),
+                    (0, entry_factories_1.createDumpEntry)({ status: 'completed' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('dump', {
+                    filters: { dumpStatuses: ['completed'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('dumpOperations', () => {
+            it('filters dumps by operation', async () => {
+                const entries = [
+                    (0, entry_factories_1.createDumpEntry)({ operation: 'export' }),
+                    (0, entry_factories_1.createDumpEntry)({ operation: 'backup' }),
+                    (0, entry_factories_1.createDumpEntry)({ operation: 'import' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('dump', {
+                    filters: { dumpOperations: ['export', 'backup'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+        describe('dumpFormats', () => {
+            it('filters dumps by format', async () => {
+                const entries = [
+                    (0, entry_factories_1.createDumpEntry)({ format: 'json' }),
+                    (0, entry_factories_1.createDumpEntry)({ format: 'sql' }),
+                    (0, entry_factories_1.createDumpEntry)({ format: 'csv' }),
+                ];
+                await (0, test_utils_1.seedStorage)(storage, entries);
+                const result = await storage.findWithCursor('dump', {
+                    filters: { dumpFormats: ['json', 'sql'] },
+                });
+                expect(result.data).toHaveLength(2);
+            });
+        });
+    });
+    // ==================== COMBINED FILTER TESTS ====================
+    describe('Combined Filters (AND logic)', () => {
+        it('applies AND logic between multiple filters', async () => {
+            const entries = [
+                (0, entry_factories_1.createLogEntry)({ level: 'error', context: 'UserService' }),
+                (0, entry_factories_1.createLogEntry)({ level: 'error', context: 'AuthController' }),
+                (0, entry_factories_1.createLogEntry)({ level: 'warn', context: 'UserService' }),
+                (0, entry_factories_1.createLogEntry)({ level: 'debug', context: 'CacheModule' }),
+            ];
+            await (0, test_utils_1.seedStorage)(storage, entries);
+            const result = await storage.findWithCursor('log', {
+                filters: {
+                    levels: ['error'],
+                    contexts: ['UserService'],
+                },
+            });
+            expect(result.data).toHaveLength(1);
+            expect(result.data[0].payload.level).toBe('error');
+            expect(result.data[0].payload.context).toBe('UserService');
+        });
+    });
+});
+//# sourceMappingURL=storage-filters.spec.js.map