bunsane 0.3.1 → 0.4.0

package/tests/integration/query/Query.explainAnalyze.test.ts

@@ -1,233 +0,0 @@
-/**
- * Integration tests for Query.explainAnalyze() and debugMode()
- * Tests query plan analysis and debug output
- */
-import { describe, test, expect, beforeAll, beforeEach } from 'bun:test';
-import { Query, FilterOp } from '../../../query/Query';
-import { TestUser, TestProduct } from '../../fixtures/components';
-import { createTestContext, ensureComponentsRegistered } from '../../utils';
-
-describe('Query EXPLAIN ANALYZE', () => {
-    const ctx = createTestContext();
-
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, TestProduct);
-    });
-
-    beforeEach(async () => {
-        // Create test data for queries
-        const entity = ctx.tracker.create();
-        entity.add(TestUser, { name: 'ExplainTest', email: 'explain@example.com', age: 30 });
-        await entity.save();
-    });
-
-    describe('explainAnalyze()', () => {
-        test('returns query execution plan', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .explainAnalyze();
-
-            expect(plan).toBeDefined();
-            expect(typeof plan).toBe('string');
-            expect(plan.length).toBeGreaterThan(0);
-        });
-
-        test('plan contains execution timing', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .explainAnalyze();
-
-            // EXPLAIN ANALYZE includes actual timing
-            expect(plan).toMatch(/actual time=/i);
-        });
-
-        test('plan contains buffer statistics by default', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .explainAnalyze(true);
-
-            // BUFFERS option includes shared/local buffer info
-            expect(plan).toMatch(/Buffers:|shared hit|shared read/i);
-        });
-
-        test('plan without buffers when buffers=false', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .explainAnalyze(false);
-
-            expect(plan).toBeDefined();
-            // Should still have timing info
-            expect(plan).toMatch(/actual time=/i);
-        });
-
-        test('explains filtered query', async () => {
-            const plan = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('name', FilterOp.EQ, 'ExplainTest')]
-                })
-                .explainAnalyze();
-
-            expect(plan).toBeDefined();
-            // Filter should show in the plan
-            expect(plan.length).toBeGreaterThan(0);
-        });
-
-        test('explains query with multiple components', async () => {
-            // Create entity with multiple components
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'MultiComp', email: 'multi@example.com', age: 25 });
-            entity.add(TestProduct, { sku: 'EXPLAIN-SKU', name: 'Explain Product', price: 100, inStock: true });
-            await entity.save();
-
-            const plan = await new Query()
-                .with(TestUser)
-                .with(TestProduct)
-                .explainAnalyze();
-
-            expect(plan).toBeDefined();
-            expect(plan.length).toBeGreaterThan(0);
-        });
-
-        test('explains query with sorting', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .sortBy(TestUser, 'age', 'DESC')
-                .explainAnalyze();
-
-            expect(plan).toBeDefined();
-            // Sort should show in plan
-            expect(plan).toMatch(/Sort|sort/i);
-        });
-
-        test('explains query with limit', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .take(10)
-                .explainAnalyze();
-
-            expect(plan).toBeDefined();
-            // Limit should show in plan
-            expect(plan).toMatch(/Limit|limit/i);
-        });
-
-        test('explains count query equivalent', async () => {
-            // explainAnalyze on a regular query shows the underlying query plan
-            // For count analysis, one would wrap the query differently
-            const plan = await new Query()
-                .with(TestUser)
-                .explainAnalyze();
-
-            expect(plan).toBeDefined();
-        });
-    });
-
-    describe('debugMode()', () => {
-        test('debugMode does not throw', async () => {
-            const results = await new Query()
-                .with(TestUser)
-                .debugMode(true)
-                .exec();
-
-            expect(Array.isArray(results)).toBe(true);
-        });
-
-        test('debugMode can be disabled', async () => {
-            const results = await new Query()
-                .with(TestUser)
-                .debugMode(true)
-                .debugMode(false)
-                .exec();
-
-            expect(Array.isArray(results)).toBe(true);
-        });
-
-        test('debugMode works with count()', async () => {
-            const count = await new Query()
-                .with(TestUser)
-                .debugMode(true)
-                .count();
-
-            expect(typeof count).toBe('number');
-        });
-
-        test('debugMode works with explainAnalyze()', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .debugMode(true)
-                .explainAnalyze();
-
-            expect(plan).toBeDefined();
-            expect(typeof plan).toBe('string');
-        });
-
-        test('debugMode works with sum()', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestProduct, { sku: 'DEBUG-SUM', name: 'Debug Sum', price: 50, inStock: true });
-            await entity.save();
-
-            const sum = await new Query()
-                .with(TestProduct)
-                .debugMode(true)
-                .sum(TestProduct, 'price');
-
-            expect(typeof sum).toBe('number');
-        });
-
-        test('debugMode works with average()', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestProduct, { sku: 'DEBUG-AVG', name: 'Debug Avg', price: 75, inStock: true });
-            await entity.save();
-
-            const avg = await new Query()
-                .with(TestProduct)
-                .debugMode(true)
-                .average(TestProduct, 'price');
-
-            expect(typeof avg).toBe('number');
-        });
-    });
-
-    describe('query plan analysis patterns', () => {
-        test('index scan shows when filtering on indexed field', async () => {
-            // Create several entities to make index usage more likely
-            for (let i = 0; i < 10; i++) {
-                const entity = ctx.tracker.create();
-                entity.add(TestUser, {
-                    name: `IndexTest${i}`,
-                    email: `index${i}@example.com`,
-                    age: 20 + i
-                });
-                await entity.save();
-            }
-
-            const plan = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('email', FilterOp.EQ, 'index5@example.com')]
-                })
-                .explainAnalyze();
-
-            expect(plan).toBeDefined();
-            // Plan should show some form of scan
-            expect(plan).toMatch(/Scan|scan/i);
-        });
-
-        test('plan shows rows estimation', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .explainAnalyze();
-
-            // EXPLAIN ANALYZE shows estimated vs actual rows
-            expect(plan).toMatch(/rows=/i);
-        });
-
-        test('plan shows execution time', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .take(5)
-                .explainAnalyze();
-
-            // Planning and execution time at the end
-            expect(plan).toMatch(/Planning Time:|Execution Time:/i);
-        });
-    });
-});

package/tests/integration/query/Query.jsonbArray.test.ts

@@ -1,214 +0,0 @@
-/**
- * Integration tests for JSONB Array Query Operators
- * Tests CONTAINS (@>), CONTAINED_BY (<@), HAS_ANY (?|), HAS_ALL (?&)
- */
-import { describe, test, expect, beforeAll, beforeEach } from 'bun:test';
-import { Query, FilterOp } from '../../../query/Query';
-import { BaseComponent } from '../../../core/components/BaseComponent';
-import { Component, CompData } from '../../../core/components/Decorators';
-import { createTestContext, ensureComponentsRegistered } from '../../utils';
-
-@Component
-class TaggedItem extends BaseComponent {
-    @CompData({ indexed: true, arrayOf: String })
-    tags: string[] = [];
-
-    @CompData({ indexed: true })
-    name: string = '';
-}
-
-@Component
-class CategoryItem extends BaseComponent {
-    @CompData({ indexed: true })
-    title: string = '';
-}
-
-const isPGlite = process.env.USE_PGLITE === 'true';
-
-describe('JSONB Array Query Operators', () => {
-    const ctx = createTestContext();
-
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TaggedItem, CategoryItem);
-    });
-
-    beforeEach(async () => {
-        // entity1: tags = ["red", "blue"]
-        const e1 = ctx.tracker.create();
-        e1.add(TaggedItem, { tags: ['red', 'blue'], name: 'item1' });
-        await e1.save();
-
-        // entity2: tags = ["blue", "green"]
-        const e2 = ctx.tracker.create();
-        e2.add(TaggedItem, { tags: ['blue', 'green'], name: 'item2' });
-        await e2.save();
-
-        // entity3: tags = ["red", "green", "blue"]
-        const e3 = ctx.tracker.create();
-        e3.add(TaggedItem, { tags: ['red', 'green', 'blue'], name: 'item3' });
-        await e3.save();
-
-        // entity4: tags = ["yellow"]
-        const e4 = ctx.tracker.create();
-        e4.add(TaggedItem, { tags: ['yellow'], name: 'item4' });
-        await e4.save();
-    });
-
-    describe('CONTAINS (@>)', () => {
-        test('finds entities where array contains a single value', async () => {
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [Query.filter('tags', FilterOp.CONTAINS, 'red')]
-                })
-                .exec();
-
-            // item1 (red,blue) and item3 (red,green,blue)
-            expect(results.length).toBe(2);
-        });
-
-        test('finds entities where array contains multiple values (AND)', async () => {
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [Query.filter('tags', FilterOp.CONTAINS, ['red', 'blue'])]
-                })
-                .exec();
-
-            // item1 (red,blue) and item3 (red,green,blue) both have red AND blue
-            expect(results.length).toBe(2);
-        });
-
-        test('returns empty when no match', async () => {
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [Query.filter('tags', FilterOp.CONTAINS, 'purple')]
-                })
-                .exec();
-
-            expect(results.length).toBe(0);
-        });
-
-        test('single element array matches', async () => {
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [Query.filter('tags', FilterOp.CONTAINS, 'yellow')]
-                })
-                .exec();
-
-            expect(results.length).toBe(1);
-        });
-
-        test('combined with other filters', async () => {
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [
-                        Query.filter('tags', FilterOp.CONTAINS, 'red'),
-                        Query.filter('name', FilterOp.EQ, 'item1'),
-                    ]
-                })
-                .exec();
-
-            expect(results.length).toBe(1);
-        });
-    });
-
-    describe('CONTAINED_BY (<@)', () => {
-        test('finds entities whose array is a subset of given values', async () => {
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [Query.filter('tags', FilterOp.CONTAINED_BY, ['red', 'blue'])]
-                })
-                .exec();
-
-            // Only item1 (red,blue) is a subset of [red,blue]
-            expect(results.length).toBe(1);
-        });
-
-        test('superset input matches all subsets', async () => {
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [Query.filter('tags', FilterOp.CONTAINED_BY, ['red', 'blue', 'green', 'yellow'])]
-                })
-                .exec();
-
-            // All 4 entities are subsets
-            expect(results.length).toBe(4);
-        });
-    });
-
-    describe.skipIf(isPGlite)('HAS_ANY (?|)', () => {
-        test('finds entities with any of the given values', async () => {
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [Query.filter('tags', FilterOp.HAS_ANY, ['red', 'yellow'])]
-                })
-                .exec();
-
-            // item1 (red), item3 (red), item4 (yellow)
-            expect(results.length).toBe(3);
-        });
-
-        test('single value works', async () => {
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [Query.filter('tags', FilterOp.HAS_ANY, ['yellow'])]
-                })
-                .exec();
-
-            expect(results.length).toBe(1);
-        });
-    });
-
-    describe.skipIf(isPGlite)('HAS_ALL (?&)', () => {
-        test('finds entities with all of the given values', async () => {
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [Query.filter('tags', FilterOp.HAS_ALL, ['red', 'green'])]
-                })
-                .exec();
-
-            // Only item3 (red,green,blue) has both red AND green
-            expect(results.length).toBe(1);
-        });
-
-        test('single value matches all entities containing it', async () => {
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [Query.filter('tags', FilterOp.HAS_ALL, ['blue'])]
-                })
-                .exec();
-
-            // item1, item2, item3 all have blue
-            expect(results.length).toBe(3);
-        });
-    });
-
-    describe('multi-component INTERSECT compatibility', () => {
-        test('CONTAINS works with multiple .with() components', async () => {
-            // Add a second component to one entity
-            const e = ctx.tracker.create();
-            e.add(TaggedItem, { tags: ['special'], name: 'multi' });
-            e.add(CategoryItem, { title: 'test-category' });
-            await e.save();
-
-            const results = await new Query()
-                .with(TaggedItem, {
-                    filters: [Query.filter('tags', FilterOp.CONTAINS, 'special')]
-                })
-                .with(CategoryItem)
-                .exec();
-
-            expect(results.length).toBe(1);
-        });
-    });
-
-    describe('validation', () => {
-        test('rejects null value via validator', () => {
-            expect(() => {
-                new Query()
-                    .with(TaggedItem, {
-                        filters: [Query.filter('tags', FilterOp.CONTAINS, null)]
-                    });
-            }).not.toThrow(); // Filter creation succeeds, validation happens at exec time
-        });
-    });
-});

package/tests/integration/remote/dlq.test.ts

@@ -1,175 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { RemoteManager } from "../../../core/remote/RemoteManager";
-import { MockRedisStreamServer } from "../../helpers/MockRedisStreamServer";
-import { createMockRedisFactory } from "../../helpers/MockRedisClient";
-
-const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
-
-describe("Dead Letter Queue", () => {
-    let server: MockRedisStreamServer;
-    let producer: RemoteManager;
-
-    beforeEach(async () => {
-        server = new MockRedisStreamServer();
-        producer = new RemoteManager({
-            appName: "prod",
-            redisFactory: createMockRedisFactory(server),
-            blockMs: 30,
-            autoClaimIdleMs: 0,
-            shutdownDrainMs: 100,
-        });
-        await producer.start();
-    });
-
-    afterEach(async () => {
-        await producer.shutdown();
-    });
-
-    test("poison message routed to DLQ after second delivery", async () => {
-        // Consumer 1: handler fails → message stays in PEL with deliveryCount=1
-        const c1 = new RemoteManager({
-            appName: "cons",
-            redisFactory: createMockRedisFactory(server),
-            blockMs: 30,
-            autoClaimIdleMs: 0,
-            dlqMaxDeliveries: 2,
-            shutdownDrainMs: 100,
-        });
-        await c1.start();
-        c1.on(
-            "poison",
-            async () => {
-                throw new Error("always fails");
-            },
-            "h1"
-        );
-        await producer.emit("cons", "poison", { bad: true });
-        await wait(200);
-        expect(server.getPelSize("remote:cons", "cons")).toBe(1);
-        await c1.shutdown();
-
-        // Consumer 2: autoClaimIdleMs > 0 triggers XAUTOCLAIM on startup →
-        // claims the orphan, deliveryCount becomes 2 → DLQ check fires.
-        const c2 = new RemoteManager({
-            appName: "cons",
-            redisFactory: createMockRedisFactory(server),
-            blockMs: 30,
-            autoClaimIdleMs: 1,
-            dlqMaxDeliveries: 2,
-            shutdownDrainMs: 100,
-            enableLogging: true,
-        });
-        await c2.start();
-        c2.on(
-            "poison",
-            async () => {
-                throw new Error("still fails");
-            },
-            "h1"
-        );
-        await wait(300);
-
-        expect(server.getStreamLength("remote:cons:dlq")).toBe(1);
-        const snap = c2.getMetrics();
-        expect(snap.events.dlq).toBe(1);
-
-        await c2.shutdown();
-    });
-
-    test("dlqMaxDeliveries=0 disables DLQ routing", async () => {
-        const c1 = new RemoteManager({
-            appName: "cons2",
-            redisFactory: createMockRedisFactory(server),
-            blockMs: 30,
-            autoClaimIdleMs: 0,
-            dlqMaxDeliveries: 0,
-            shutdownDrainMs: 100,
-        });
-        await c1.start();
-        c1.on(
-            "fail",
-            async () => {
-                throw new Error("x");
-            },
-            "h1"
-        );
-        await producer.emit("cons2", "fail", {});
-        await wait(200);
-        await c1.shutdown();
-
-        const c2 = new RemoteManager({
-            appName: "cons2",
-            redisFactory: createMockRedisFactory(server),
-            blockMs: 30,
-            autoClaimIdleMs: 1,
-            dlqMaxDeliveries: 0,
-            shutdownDrainMs: 100,
-        });
-        await c2.start();
-        c2.on(
-            "fail",
-            async () => {
-                throw new Error("x");
-            },
-            "h1"
-        );
-        await wait(300);
-
-        expect(server.getStreamLength("remote:cons2:dlq")).toBe(0);
-
-        await c2.shutdown();
-    });
-
-    test("DLQ entry carries original_id + delivery_count metadata", async () => {
-        const c1 = new RemoteManager({
-            appName: "cons3",
-            redisFactory: createMockRedisFactory(server),
-            blockMs: 30,
-            autoClaimIdleMs: 0,
-            dlqMaxDeliveries: 2,
-            shutdownDrainMs: 100,
-        });
-        await c1.start();
-        c1.on(
-            "p",
-            async () => {
-                throw new Error("x");
-            },
-            "h1"
-        );
-        await producer.emit("cons3", "p", {});
-        await wait(200);
-        await c1.shutdown();
-
-        const c2 = new RemoteManager({
-            appName: "cons3",
-            redisFactory: createMockRedisFactory(server),
-            blockMs: 30,
-            autoClaimIdleMs: 1,
-            dlqMaxDeliveries: 2,
-            shutdownDrainMs: 100,
-        });
-        await c2.start();
-        c2.on(
-            "p",
-            async () => {
-                throw new Error("x");
-            },
-            "h1"
-        );
-        await wait(300);
-
-        const dlqEntries = server.xrange("remote:cons3:dlq", "-", "+");
-        expect(dlqEntries.length).toBe(1);
-        const [, fields] = dlqEntries[0]!;
-        // fields = [k1, v1, k2, v2, ...]
-        const flat = fields as string[];
-        const idx = (k: string) => flat.indexOf(k);
-        expect(idx("original_id")).toBeGreaterThanOrEqual(0);
-        expect(idx("delivery_count")).toBeGreaterThanOrEqual(0);
-        expect(idx("moved_at")).toBeGreaterThanOrEqual(0);
-        expect(idx("data")).toBeGreaterThanOrEqual(0);
-
-        await c2.shutdown();
-    });
-});