bunsane 0.2.7 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "bunsane",
-    "version": "0.2.7",
+    "version": "0.2.8",
     "author": {
         "name": "yaaruu"
     },

package/query/ComponentInclusionNode.ts

@@ -54,11 +54,15 @@ export class ComponentInclusionNode extends QueryNode {
 
         let sql = "";
         const componentCount = componentIds.length;
-        const useLateralJoins = Boolean(shouldUseLateralJoins());
 
         // Check if CTE is available and use it to avoid redundant entity_components scans
         const useCTE = Boolean(context.hasCTE && context.cteName);
 
+        // LATERAL joins don't work correctly with INTERSECT queries (non-CTE multi-component)
+        // because the SQL insertion logic places joins inside the INTERSECT subqueries
+        const isIntersectQuery = componentCount > 1 && !useCTE;
+        const useLateralJoins = Boolean(shouldUseLateralJoins()) && !isIntersectQuery;
+
         // Collect LATERAL join fragments if using LATERAL joins
         const lateralJoins: string[] = [];
         const lateralConditions: string[] = [];
@@ -430,11 +434,11 @@ export class ComponentInclusionNode extends QueryNode {
             } else if (typeof filter.value === 'boolean') {
                 condition = `(${jsonPath})::boolean ${filter.operator} $${context.addParam(filter.value)}`;
             } else if (filter.operator === 'IN' || filter.operator === 'NOT IN') {
-                if (Array.isArray(filter.value)) {
+                if (Array.isArray(filter.value) && filter.value.length > 0) {
                     const placeholders = filter.value.map((v: any) => `$${context.addParam(v)}`).join(', ');
                     condition = `${jsonPath} ${filter.operator} (${placeholders})`;
                 } else {
-                    return null; // Invalid - fall back to normal path
+                    return null; // Invalid or empty array - fall back to normal path
                 }
             } else if (filter.operator === 'LIKE' || filter.operator === 'NOT LIKE' || filter.operator === 'ILIKE') {
                 condition = `${jsonPath} ${filter.operator} $${context.addParam(filter.value)}::text`;
@@ -445,6 +449,9 @@ export class ComponentInclusionNode extends QueryNode {
             filterConditions.push(condition);
         }
 
+        // Guard: if no conditions were built, fall back to normal path
+        if (filterConditions.length === 0) return null;
+
         const nullsClause = sortOrder.nullsFirst ? 'NULLS FIRST' : 'NULLS LAST';
         const isNumeric = isNumericProperty(sortOrder.component, sortOrder.property);
         const sortExpr = isNumeric
@@ -622,9 +629,12 @@ export class ComponentInclusionNode extends QueryNode {
                         condition = `${jsonPath} ${filter.operator} $${context.addParam(filter.value)}`;
                     } else if (filter.operator === 'IN' || filter.operator === 'NOT IN') {
                         // IN/NOT IN comparison - handle arrays properly
-                        if (Array.isArray(filter.value)) {
+                        if (Array.isArray(filter.value) && filter.value.length > 0) {
                             const placeholders = Array.from({length: filter.value.length}, (_, i) => `$${context.addParam(filter.value[i])}`).join(', ');
                             condition = `${jsonPath} ${filter.operator} (${placeholders})`;
+                        } else if (Array.isArray(filter.value) && filter.value.length === 0) {
+                            // Empty array: IN () is always false, NOT IN () is always true
+                            condition = filter.operator === 'IN' ? 'FALSE' : 'TRUE';
                         } else {
                             throw new Error(`${filter.operator} operator requires an array of values`);
                         }

package/tests/benchmark/query-lateral-benchmark.test.ts

@@ -0,0 +1,372 @@
+/**
+ * Benchmark: LATERAL joins vs EXISTS subqueries for multi-component queries
+ *
+ * Tests the performance impact of the INTERSECT query fix that disables
+ * LATERAL joins for multi-component non-CTE queries.
+ */
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { Entity } from '../../core/Entity';
+import { Query, FilterOp } from '../../query/Query';
+import { Component, CompData, BaseComponent } from '../../core/components';
+import { ComponentRegistry } from '../../core/components/ComponentRegistry';
+import { ensureComponentsRegistered } from '../utils';
+
+// Benchmark components
+@Component
+class BenchUser extends BaseComponent {
+    @CompData({ indexed: true }) name: string = '';
+    @CompData({ indexed: true }) email: string = '';
+    @CompData() age: number = 0;
+    @CompData() status: string = 'active';
+}
+
+@Component
+class BenchProfile extends BaseComponent {
+    @CompData({ indexed: true }) username: string = '';
+    @CompData() bio: string = '';
+    @CompData() verified: boolean = false;
+}
+
+@Component
+class BenchSettings extends BaseComponent {
+    @CompData() theme: string = 'light';
+    @CompData() notifications: boolean = true;
+    @CompData() language: string = 'en';
+}
+
+// Test configuration
+const DATASET_SIZES = {
+    small: 100,
+    medium: 1000,
+    large: 5000
+};
+
+const ITERATIONS = 5; // Number of times to run each query for averaging
+
+interface BenchmarkResult {
+    name: string;
+    datasetSize: number;
+    avgTimeMs: number;
+    minTimeMs: number;
+    maxTimeMs: number;
+    resultCount: number;
+}
+
+async function runBenchmark(
+    name: string,
+    datasetSize: number,
+    queryFn: () => Promise<Entity[]>
+): Promise<BenchmarkResult> {
+    const times: number[] = [];
+    let resultCount = 0;
+
+    for (let i = 0; i < ITERATIONS; i++) {
+        const start = performance.now();
+        const results = await queryFn();
+        const end = performance.now();
+        times.push(end - start);
+        resultCount = results.length;
+    }
+
+    return {
+        name,
+        datasetSize,
+        avgTimeMs: times.reduce((a, b) => a + b, 0) / times.length,
+        minTimeMs: Math.min(...times),
+        maxTimeMs: Math.max(...times),
+        resultCount
+    };
+}
+
+describe('Query Performance Benchmark', () => {
+    const createdEntityIds: string[] = [];
+    const datasetSize = DATASET_SIZES.large; // 5000 entities
+
+    beforeAll(async () => {
+        await ensureComponentsRegistered(BenchUser, BenchProfile, BenchSettings);
+
+        console.log(`\n📊 Creating ${datasetSize} test entities...`);
+        const startCreate = performance.now();
+
+        // Create entities with various component combinations
+        for (let i = 0; i < datasetSize; i++) {
+            const entity = Entity.Create();
+
+            // All entities have BenchUser
+            entity.add(BenchUser, {
+                name: `User ${i}`,
+                email: `user${i}@test.com`,
+                age: 18 + (i % 60),
+                status: i % 3 === 0 ? 'active' : (i % 3 === 1 ? 'inactive' : 'pending')
+            });
+
+            // 80% have BenchProfile
+            if (i % 5 !== 0) {
+                entity.add(BenchProfile, {
+                    username: `user_${i}`,
+                    bio: `Bio for user ${i}`,
+                    verified: i % 2 === 0
+                });
+            }
+
+            // 60% have BenchSettings
+            if (i % 5 < 3) {
+                entity.add(BenchSettings, {
+                    theme: i % 2 === 0 ? 'light' : 'dark',
+                    notifications: i % 3 !== 0,
+                    language: ['en', 'es', 'fr', 'de'][i % 4]!
+                });
+            }
+
+            await entity.save();
+            createdEntityIds.push(entity.id);
+        }
+
+        const endCreate = performance.now();
+        console.log(`✅ Created ${datasetSize} entities in ${(endCreate - startCreate).toFixed(0)}ms\n`);
+    }, 120000); // 2 minute timeout for setup
+
+    afterAll(async () => {
+        // Cleanup
+        console.log(`\n🧹 Cleaning up ${createdEntityIds.length} entities...`);
+        for (const id of createdEntityIds) {
+            try {
+                const entity = await Entity.findById(id);
+                if (entity) {
+                    await entity.delete();
+                }
+            } catch {
+                // Ignore cleanup errors
+            }
+        }
+    }, 120000);
+
+    describe('Single component queries (baseline)', () => {
+        test('single component, no filter', async () => {
+            const result = await runBenchmark(
+                'Single component, no filter',
+                datasetSize,
+                () => new Query().with(BenchUser).take(100).exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(1000);
+        });
+
+        test('single component, with filter', async () => {
+            const result = await runBenchmark(
+                'Single component, with filter',
+                datasetSize,
+                () => new Query()
+                    .with(BenchUser, {
+                        filters: [Query.filter('status', FilterOp.EQ, 'active')]
+                    })
+                    .take(100)
+                    .exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(1000);
+        });
+    });
+
+    describe('Two component queries (affected by fix)', () => {
+        test('2 components, no filter', async () => {
+            const result = await runBenchmark(
+                '2 components, no filter',
+                datasetSize,
+                () => new Query()
+                    .with(BenchUser)
+                    .with(BenchProfile)
+                    .take(100)
+                    .exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(2000);
+        });
+
+        test('2 components, filter on first (bug pattern)', async () => {
+            const result = await runBenchmark(
+                '2 components, filter on first',
+                datasetSize,
+                () => new Query()
+                    .with(BenchUser, {
+                        filters: [Query.filter('status', FilterOp.EQ, 'active')]
+                    })
+                    .with(BenchProfile)
+                    .take(100)
+                    .exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(2000);
+        });
+
+        test('2 components, filter on second (bug pattern)', async () => {
+            const result = await runBenchmark(
+                '2 components, filter on second',
+                datasetSize,
+                () => new Query()
+                    .with(BenchUser)
+                    .with(BenchProfile, {
+                        filters: [Query.filter('verified', FilterOp.EQ, true)]
+                    })
+                    .take(100)
+                    .exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(2000);
+        });
+
+        test('2 components, filters on both', async () => {
+            const result = await runBenchmark(
+                '2 components, filters on both',
+                datasetSize,
+                () => new Query()
+                    .with(BenchUser, {
+                        filters: [Query.filter('status', FilterOp.EQ, 'active')]
+                    })
+                    .with(BenchProfile, {
+                        filters: [Query.filter('verified', FilterOp.EQ, true)]
+                    })
+                    .take(100)
+                    .exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(2000);
+        });
+
+        test('2 components, IN filter (bug pattern)', async () => {
+            const result = await runBenchmark(
+                '2 components, IN filter',
+                datasetSize,
+                () => new Query()
+                    .with(BenchUser, {
+                        filters: [Query.filter('status', FilterOp.IN, ['active', 'pending'])]
+                    })
+                    .with(BenchProfile)
+                    .take(100)
+                    .exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(2000);
+        });
+    });
+
+    describe('Three component queries', () => {
+        test('3 components, no filter', async () => {
+            const result = await runBenchmark(
+                '3 components, no filter',
+                datasetSize,
+                () => new Query()
+                    .with(BenchUser)
+                    .with(BenchProfile)
+                    .with(BenchSettings)
+                    .take(100)
+                    .exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(3000);
+        });
+
+        test('3 components, filter on one', async () => {
+            const result = await runBenchmark(
+                '3 components, filter on one',
+                datasetSize,
+                () => new Query()
+                    .with(BenchUser, {
+                        filters: [Query.filter('age', FilterOp.GTE, 30)]
+                    })
+                    .with(BenchProfile)
+                    .with(BenchSettings)
+                    .take(100)
+                    .exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(3000);
+        });
+
+        test('3 components, filters on all', async () => {
+            const result = await runBenchmark(
+                '3 components, filters on all',
+                datasetSize,
+                () => new Query()
+                    .with(BenchUser, {
+                        filters: [Query.filter('status', FilterOp.EQ, 'active')]
+                    })
+                    .with(BenchProfile, {
+                        filters: [Query.filter('verified', FilterOp.EQ, true)]
+                    })
+                    .with(BenchSettings, {
+                        filters: [Query.filter('theme', FilterOp.EQ, 'dark')]
+                    })
+                    .take(100)
+                    .exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(3000);
+        });
+    });
+
+    describe('Sorting with multi-component (affected by fix)', () => {
+        test('2 components, sort on first', async () => {
+            const result = await runBenchmark(
+                '2 components, sort on first',
+                datasetSize,
+                () => new Query()
+                    .with(BenchUser)
+                    .with(BenchProfile)
+                    .sortBy(BenchUser, 'age', 'DESC')
+                    .take(100)
+                    .exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(3000);
+        });
+
+        test('2 components, filter + sort on different components', async () => {
+            const result = await runBenchmark(
+                '2 components, filter + sort different',
+                datasetSize,
+                () => new Query()
+                    .with(BenchUser)
+                    .with(BenchProfile, {
+                        filters: [Query.filter('verified', FilterOp.EQ, true)]
+                    })
+                    .sortBy(BenchUser, 'age', 'ASC')
+                    .take(100)
+                    .exec()
+            );
+            console.log(`  ${result.name}: ${result.avgTimeMs.toFixed(2)}ms avg (${result.resultCount} results)`);
+            expect(result.avgTimeMs).toBeLessThan(3000);
+        });
+    });
+
+    describe('Count operations', () => {
+        test('2 components count with filter', async () => {
+            const times: number[] = [];
+            let count = 0;
+
+            for (let i = 0; i < ITERATIONS; i++) {
+                const start = performance.now();
+                count = await new Query()
+                    .with(BenchUser, {
+                        filters: [Query.filter('status', FilterOp.EQ, 'active')]
+                    })
+                    .with(BenchProfile)
+                    .count();
+                const end = performance.now();
+                times.push(end - start);
+            }
+
+            const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
+            console.log(`  2 components count with filter: ${avgTime.toFixed(2)}ms avg (count: ${count})`);
+            expect(avgTime).toBeLessThan(2000);
+        });
+    });
+
+    test('Performance summary', () => {
+        console.log('\n📈 Benchmark Summary:');
+        console.log(`   Dataset size: ${datasetSize} entities`);
+        console.log(`   Iterations per query: ${ITERATIONS}`);
+        console.log('   All queries completed within acceptable thresholds');
+        expect(true).toBe(true);
+    });
+});

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

@@ -0,0 +1,595 @@
+/**
+ * Edge case tests for Query SQL generation
+ * These tests verify that various edge cases don't produce invalid SQL
+ */
+import { describe, test, expect, beforeAll, beforeEach } from 'bun:test';
+import { Entity } from '../../../core/Entity';
+import { Query, FilterOp } from '../../../query/Query';
+import { TestUser, TestProduct, TestOrder } from '../../fixtures/components';
+import { createTestContext, ensureComponentsRegistered } from '../../utils';
+
+describe('Query Edge Cases', () => {
+    const ctx = createTestContext();
+
+    beforeAll(async () => {
+        await ensureComponentsRegistered(TestUser, TestProduct, TestOrder);
+    });
+
+    describe('IN/NOT IN operator edge cases', () => {
+        beforeEach(async () => {
+            // Create test data
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'InTest', email: 'in@test.com', age: 25 });
+            await entity.save();
+        });
+
+        test('IN with single element array works', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('name', FilterOp.IN, ['InTest'])]
+                })
+                .exec();
+
+            expect(results.length).toBeGreaterThanOrEqual(1);
+        });
+
+        test('IN with multiple elements works', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('name', FilterOp.IN, ['InTest', 'Other', 'Another'])]
+                })
+                .exec();
+
+            expect(results.length).toBeGreaterThanOrEqual(1);
+        });
+
+        test('IN with empty array returns no results (not SQL error)', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('name', FilterOp.IN, [])]
+                })
+                .exec();
+
+            // Empty IN should return no results, not throw SQL error
+            expect(results.length).toBe(0);
+        });
+
+        test('NOT IN with empty array returns all results (not SQL error)', async () => {
+            const allResults = await new Query()
+                .with(TestUser)
+                .exec();
+
+            const notInResults = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('name', FilterOp.NOT_IN, [])]
+                })
+                .exec();
+
+            // Empty NOT IN should return all results (nothing excluded)
+            expect(notInResults.length).toBe(allResults.length);
+        });
+
+        test('NOT IN with single element works', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('name', FilterOp.NOT_IN, ['InTest'])]
+                })
+                .exec();
+
+            // Should not include 'InTest'
+            const hasInTest = results.some(e => e.getInMemory(TestUser)?.name === 'InTest');
+            expect(hasInTest).toBe(false);
+        });
+
+        test('IN combined with other filters works', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [
+                        Query.filter('name', FilterOp.IN, ['InTest', 'Other']),
+                        Query.filter('age', FilterOp.GTE, 18)
+                    ]
+                })
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+    });
+
+    describe('Multi-component query edge cases', () => {
+        beforeEach(async () => {
+            // Create entity with multiple components
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'MultiComp', email: 'multi@test.com', age: 30 });
+            entity.add(TestProduct, { sku: 'MULTI-SKU', name: 'Multi Product', price: 100, inStock: true });
+            await entity.save();
+
+            // Create entity with only user
+            const userOnly = ctx.tracker.create();
+            userOnly.add(TestUser, { name: 'UserOnly', email: 'useronly@test.com', age: 25 });
+            await userOnly.save();
+        });
+
+        test('two components with no filters works', async () => {
+            const results = await new Query()
+                .with(TestUser)
+                .with(TestProduct)
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+
+        test('two components with filter on first works', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('name', FilterOp.EQ, 'MultiComp')]
+                })
+                .with(TestProduct)
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+
+        test('two components with filter on second works', async () => {
+            const results = await new Query()
+                .with(TestUser)
+                .with(TestProduct, {
+                    filters: [Query.filter('sku', FilterOp.EQ, 'MULTI-SKU')]
+                })
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+
+        test('two components with filters on both works', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('name', FilterOp.EQ, 'MultiComp')]
+                })
+                .with(TestProduct, {
+                    filters: [Query.filter('price', FilterOp.GTE, 50)]
+                })
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+
+        test('three components with mixed filters works', async () => {
+            // Add order to existing entity
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'TripleComp', email: 'triple@test.com', age: 35 });
+            entity.add(TestProduct, { sku: 'TRIPLE-SKU', name: 'Triple Product', price: 200, inStock: true });
+            entity.add(TestOrder, { orderNumber: 'ORD-TRIPLE', status: 'pending', total: 200 });
+            await entity.save();
+
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('age', FilterOp.GTE, 18)]
+                })
+                .with(TestProduct)
+                .with(TestOrder, {
+                    filters: [Query.filter('status', FilterOp.EQ, 'pending')]
+                })
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+    });
+
+    describe('Sorting edge cases', () => {
+        beforeEach(async () => {
+            // Create entities with various ages
+            for (const age of [20, 30, 40]) {
+                const entity = ctx.tracker.create();
+                entity.add(TestUser, {
+                    name: `SortEdge${age}`,
+                    email: `sortedge${age}@test.com`,
+                    age
+                });
+                await entity.save();
+            }
+        });
+
+        test('sort with no filters works', async () => {
+            const results = await new Query()
+                .with(TestUser)
+                .sortBy(TestUser, 'age', 'ASC')
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+
+        test('sort with filter on same component works', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('email', FilterOp.LIKE, 'sortedge%')]
+                })
+                .sortBy(TestUser, 'age', 'DESC')
+                .populate()
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+            // Verify sort order
+            for (let i = 1; i < results.length; i++) {
+                const prevAge = results[i - 1]!.getInMemory(TestUser)?.age ?? 0;
+                const currAge = results[i]!.getInMemory(TestUser)?.age ?? 0;
+                expect(currAge).toBeLessThanOrEqual(prevAge);
+            }
+        });
+
+        test('sort on component different from filter works', async () => {
+            // Create entity with both components
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'SortDiffComp', email: 'sortdiff@test.com', age: 50 });
+            entity.add(TestProduct, { sku: 'SORT-DIFF', name: 'Sort Product', price: 75, inStock: true });
+            await entity.save();
+
+            const results = await new Query()
+                .with(TestUser)
+                .with(TestProduct, {
+                    filters: [Query.filter('price', FilterOp.GTE, 50)]
+                })
+                .sortBy(TestUser, 'age', 'ASC')
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+
+        test('multi-component query with sort works', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'MultiSort', email: 'multisort@test.com', age: 28 });
+            entity.add(TestProduct, { sku: 'MULTI-SORT', name: 'MultiSort Product', price: 150, inStock: true });
+            await entity.save();
+
+            const results = await new Query()
+                .with(TestUser)
+                .with(TestProduct)
+                .sortBy(TestProduct, 'price', 'DESC')
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+    });
+
+    describe('Exclusion edge cases', () => {
+        test('without() with no matching entities works', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'WithoutTest', email: 'without@test.com', age: 22 });
+            await entity.save();
+
+            const results = await new Query()
+                .with(TestUser)
+                .without(TestOrder) // This entity doesn't have TestOrder
+                .exec();
+
+            expect(results.some(e => e.id === entity.id)).toBe(true);
+        });
+
+        test('excludeEntityId with non-existent ID works', async () => {
+            const results = await new Query()
+                .with(TestUser)
+                .excludeEntityId('00000000-0000-0000-0000-000000000000')
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+
+        test('multiple excludeEntityId calls work', async () => {
+            const entity1 = ctx.tracker.create();
+            entity1.add(TestUser, { name: 'Exclude1', email: 'exclude1@test.com', age: 30 });
+            await entity1.save();
+
+            const entity2 = ctx.tracker.create();
+            entity2.add(TestUser, { name: 'Exclude2', email: 'exclude2@test.com', age: 31 });
+            await entity2.save();
+
+            const results = await new Query()
+                .with(TestUser)
+                .excludeEntityId(entity1.id)
+                .excludeEntityId(entity2.id)
+                .exec();
+
+            expect(results.some(e => e.id === entity1.id)).toBe(false);
+            expect(results.some(e => e.id === entity2.id)).toBe(false);
+        });
+
+        test('without() combined with filters works', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('age', FilterOp.GTE, 18)]
+                })
+                .without(TestProduct)
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+    });
+
+    describe('Pagination edge cases', () => {
+        test('limit 0 returns empty array', async () => {
+            const results = await new Query()
+                .with(TestUser)
+                .take(0)
+                .exec();
+
+            expect(results.length).toBe(0);
+        });
+
+        test('offset larger than result set returns empty', async () => {
+            const count = await new Query().with(TestUser).count();
+
+            const results = await new Query()
+                .with(TestUser)
+                .offset(count + 100)
+                .take(10)
+                .exec();
+
+            expect(results.length).toBe(0);
+        });
+
+        test('pagination with filters works', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('age', FilterOp.GTE, 18)]
+                })
+                .take(5)
+                .offset(0)
+                .exec();
+
+            expect(results.length).toBeLessThanOrEqual(5);
+        });
+
+        test('pagination with sort works', async () => {
+            const results = await new Query()
+                .with(TestUser)
+                .sortBy(TestUser, 'age', 'ASC')
+                .take(5)
+                .offset(0)
+                .exec();
+
+            expect(results.length).toBeLessThanOrEqual(5);
+        });
+
+        test('pagination with multi-component query works', async () => {
+            const results = await new Query()
+                .with(TestUser)
+                .with(TestProduct)
+                .take(5)
+                .offset(0)
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+    });
+
+    describe('Boolean filter edge cases', () => {
+        beforeEach(async () => {
+            const inStock = ctx.tracker.create();
+            inStock.add(TestProduct, { sku: 'BOOL-IN', name: 'In Stock', price: 50, inStock: true });
+            await inStock.save();
+
+            const outOfStock = ctx.tracker.create();
+            outOfStock.add(TestProduct, { sku: 'BOOL-OUT', name: 'Out of Stock', price: 50, inStock: false });
+            await outOfStock.save();
+        });
+
+        test('boolean true filter works', async () => {
+            const results = await new Query()
+                .with(TestProduct, {
+                    filters: [Query.filter('inStock', FilterOp.EQ, true)]
+                })
+                .populate()
+                .exec();
+
+            for (const entity of results) {
+                const product = entity.getInMemory(TestProduct);
+                if (product) {
+                    expect(product.inStock).toBe(true);
+                }
+            }
+        });
+
+        test('boolean false filter works', async () => {
+            const results = await new Query()
+                .with(TestProduct, {
+                    filters: [Query.filter('inStock', FilterOp.EQ, false)]
+                })
+                .populate()
+                .exec();
+
+            for (const entity of results) {
+                const product = entity.getInMemory(TestProduct);
+                if (product) {
+                    expect(product.inStock).toBe(false);
+                }
+            }
+        });
+    });
+
+    describe('Numeric filter edge cases', () => {
+        test('zero value filter works', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestProduct, { sku: 'ZERO-PRICE', name: 'Free Product', price: 0, inStock: true });
+            await entity.save();
+
+            const results = await new Query()
+                .with(TestProduct, {
+                    filters: [Query.filter('price', FilterOp.EQ, 0)]
+                })
+                .exec();
+
+            expect(results.length).toBeGreaterThanOrEqual(1);
+        });
+
+        test('negative value filter works', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'NegAge', email: 'neg@test.com', age: -1 });
+            await entity.save();
+
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('age', FilterOp.LT, 0)]
+                })
+                .exec();
+
+            expect(results.length).toBeGreaterThanOrEqual(1);
+        });
+
+        test('large number filter works', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestProduct, { sku: 'LARGE-PRICE', name: 'Expensive', price: 999999999, inStock: true });
+            await entity.save();
+
+            const results = await new Query()
+                .with(TestProduct, {
+                    filters: [Query.filter('price', FilterOp.GTE, 999999999)]
+                })
+                .exec();
+
+            expect(results.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+
+    describe('String filter edge cases', () => {
+        test('LIKE with special characters works', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'Test%User', email: 'special@test.com', age: 25 });
+            await entity.save();
+
+            // Note: % in LIKE is a wildcard, so this tests the pattern matching
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('email', FilterOp.LIKE, '%special@test.com')]
+                })
+                .exec();
+
+            expect(results.length).toBeGreaterThanOrEqual(1);
+        });
+
+        test('ILIKE case-insensitive filter works', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'CaseTest', email: 'UPPERCASE@TEST.COM', age: 25 });
+            await entity.save();
+
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('email', FilterOp.ILIKE, '%uppercase@test.com%')]
+                })
+                .exec();
+
+            expect(results.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+
+    describe('Bug reproduction: 2 components, 1 filter, LATERAL joins', () => {
+        // This is the exact pattern from the bug report:
+        // new Query().with(UserTag).with(PhoneComponent, Query.filters(...)).take(1).exec()
+
+        test('exact bug pattern: 2 components, filter on second, take(1)', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'BugRepro', email: 'bug@test.com', age: 30 });
+            entity.add(TestProduct, { sku: 'BUG-SKU', name: 'Bug Product', price: 100, inStock: true });
+            await entity.save();
+
+            // This is the exact failing pattern
+            const results = await new Query()
+                .with(TestUser)
+                .with(TestProduct, {
+                    filters: [Query.filter('sku', FilterOp.EQ, 'BUG-SKU')]
+                })
+                .take(1)
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+            expect(results.length).toBeLessThanOrEqual(1);
+        });
+
+        test('verify SQL is valid for bug pattern', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'SQLVerify', email: 'sql@test.com', age: 25 });
+            entity.add(TestProduct, { sku: 'SQL-SKU', name: 'SQL Product', price: 50, inStock: true });
+            await entity.save();
+
+            // Should not throw SQL syntax error
+            const results = await new Query()
+                .with(TestUser)
+                .with(TestProduct, {
+                    filters: [Query.filter('name', FilterOp.LIKE, '%SQL%')]
+                })
+                .take(10)
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+    });
+
+    describe('Combined complex queries', () => {
+        test('all features combined works', async () => {
+            // Create test data
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'ComplexTest', email: 'complex@test.com', age: 30 });
+            entity.add(TestProduct, { sku: 'COMPLEX-SKU', name: 'Complex Product', price: 100, inStock: true });
+            await entity.save();
+
+            // Query with everything
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [
+                        Query.filter('age', FilterOp.GTE, 18),
+                        Query.filter('name', FilterOp.LIKE, 'Complex%')
+                    ]
+                })
+                .with(TestProduct, {
+                    filters: [Query.filter('inStock', FilterOp.EQ, true)]
+                })
+                .without(TestOrder)
+                .sortBy(TestUser, 'age', 'DESC')
+                .take(10)
+                .offset(0)
+                .populate()
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+
+        test('multi-component with IN filter and sort works', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'InSortTest', email: 'insort@test.com', age: 35 });
+            entity.add(TestProduct, { sku: 'IN-SORT-SKU', name: 'InSort Product', price: 75, inStock: true });
+            await entity.save();
+
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('name', FilterOp.IN, ['InSortTest', 'Other'])]
+                })
+                .with(TestProduct)
+                .sortBy(TestProduct, 'price', 'ASC')
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+
+        test('filters on all components with pagination works', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'AllFilters', email: 'allfilters@test.com', age: 40 });
+            entity.add(TestProduct, { sku: 'ALL-FILTERS', name: 'All Filters Product', price: 200, inStock: true });
+            entity.add(TestOrder, { orderNumber: 'ORD-ALL', status: 'completed', total: 200 });
+            await entity.save();
+
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('age', FilterOp.GTE, 30)]
+                })
+                .with(TestProduct, {
+                    filters: [Query.filter('price', FilterOp.GTE, 100)]
+                })
+                .with(TestOrder, {
+                    filters: [Query.filter('status', FilterOp.EQ, 'completed')]
+                })
+                .take(5)
+                .offset(0)
+                .exec();
+
+            expect(Array.isArray(results)).toBe(true);
+        });
+    });
+});