bunsane 0.3.1 → 0.4.0

package/tests/unit/query/FilterBuilder.test.ts

@@ -1,111 +0,0 @@
-/**
- * Unit tests for FilterBuilder utility functions
- */
-import { describe, test, expect } from 'bun:test';
-import { buildJSONPath, composeFilters, type FilterBuilder, type FilterResult } from '../../../query/FilterBuilder';
-
-describe('FilterBuilder', () => {
-    describe('buildJSONPath()', () => {
-        test('builds simple field path', () => {
-            const result = buildJSONPath('name', 'c');
-            expect(result).toBe("c.data->>'name'");
-        });
-
-        test('builds nested field path', () => {
-            const result = buildJSONPath('location.latitude', 'c');
-            expect(result).toBe("c.data->'location'->>'latitude'");
-        });
-
-        test('builds deeply nested path', () => {
-            const result = buildJSONPath('device.location.coordinates.latitude', 'c');
-            expect(result).toBe("c.data->'device'->'location'->'coordinates'->>'latitude'");
-        });
-
-        test('uses provided alias', () => {
-            const result = buildJSONPath('field', 'comp');
-            expect(result).toBe("comp.data->>'field'");
-        });
-    });
-
-    describe('composeFilters()', () => {
-        test('throws for empty array', () => {
-            expect(() => composeFilters([])).toThrow('Cannot compose empty array of filter builders');
-        });
-
-        test('composes single builder', () => {
-            const mockBuilder: FilterBuilder = () => ({
-                sql: 'field = $1',
-                addedParams: 1
-            });
-
-            const composed = composeFilters([mockBuilder]);
-            const result = composed(
-                { field: 'test', operator: 'EQ', value: 'value' },
-                'c',
-                {} as any
-            );
-
-            expect(result.sql).toBe('(field = $1)');
-            expect(result.addedParams).toBe(1);
-        });
-
-        test('composes multiple builders with AND', () => {
-            const builder1: FilterBuilder = () => ({
-                sql: 'field1 = $1',
-                addedParams: 1
-            });
-            const builder2: FilterBuilder = () => ({
-                sql: 'field2 > $2',
-                addedParams: 1
-            });
-
-            const composed = composeFilters([builder1, builder2]);
-            const result = composed(
-                { field: 'test', operator: 'EQ', value: 'value' },
-                'c',
-                {} as any
-            );
-
-            expect(result.sql).toBe('(field1 = $1) AND (field2 > $2)');
-            expect(result.addedParams).toBe(2);
-        });
-
-        test('handles empty SQL from builder', () => {
-            const builder1: FilterBuilder = () => ({
-                sql: 'field1 = $1',
-                addedParams: 1
-            });
-            const builder2: FilterBuilder = () => ({
-                sql: '',
-                addedParams: 0
-            });
-
-            const composed = composeFilters([builder1, builder2]);
-            const result = composed(
-                { field: 'test', operator: 'EQ', value: 'value' },
-                'c',
-                {} as any
-            );
-
-            expect(result.sql).toBe('(field1 = $1)');
-            expect(result.addedParams).toBe(1);
-        });
-
-        test('handles whitespace-only SQL', () => {
-            const builder: FilterBuilder = () => ({
-                sql: '   ',
-                addedParams: 0
-            });
-
-            const composed = composeFilters([builder]);
-            const result = composed(
-                { field: 'test', operator: 'EQ', value: 'value' },
-                'c',
-                {} as any
-            );
-
-            expect(result.sql).toBe('');
-            expect(result.addedParams).toBe(0);
-        });
-    });
-});

package/tests/unit/query/JsonbArrayBuilder.test.ts

@@ -1,178 +0,0 @@
-/**
- * Unit tests for JSONB Array Filter Builders
- */
-import { describe, test, expect } from 'bun:test';
-import { buildJSONBPath } from '../../../query/FilterBuilder';
-import { QueryContext } from '../../../query/QueryContext';
-import {
-    jsonbContainsBuilder,
-    jsonbContainedByBuilder,
-    jsonbHasAnyBuilder,
-    jsonbHasAllBuilder,
-    jsonbArrayOptions,
-} from '../../../query/builders/JsonbArrayBuilder';
-
-describe('buildJSONBPath', () => {
-    test('simple field returns JSONB node path', () => {
-        expect(buildJSONBPath('tags', 'c')).toBe("c.data->'tags'");
-    });
-
-    test('nested field returns JSONB node path', () => {
-        expect(buildJSONBPath('metadata.tags', 'c')).toBe("c.data->'metadata'->'tags'");
-    });
-
-    test('deeply nested field', () => {
-        expect(buildJSONBPath('a.b.c', 'c')).toBe("c.data->'a'->'b'->'c'");
-    });
-
-    test('uses provided alias', () => {
-        expect(buildJSONBPath('tags', 'comp')).toBe("comp.data->'tags'");
-    });
-});
-
-describe('jsonbContainsBuilder (@>)', () => {
-    test('single string value is auto-wrapped in array', () => {
-        const ctx = new QueryContext();
-        const result = jsonbContainsBuilder(
-            { field: 'tags', operator: 'CONTAINS', value: 'urgent' },
-            'c', ctx
-        );
-        expect(result.sql).toBe("c.data->'tags' @> $1::jsonb");
-        expect(ctx.params[0]).toEqual(['urgent']);
-        expect(result.addedParams).toBe(1);
-    });
-
-    test('array value is passed as raw array', () => {
-        const ctx = new QueryContext();
-        const result = jsonbContainsBuilder(
-            { field: 'tags', operator: 'CONTAINS', value: ['a', 'b'] },
-            'c', ctx
-        );
-        expect(result.sql).toBe("c.data->'tags' @> $1::jsonb");
-        expect(ctx.params[0]).toEqual(['a', 'b']);
-    });
-
-    test('nested field path', () => {
-        const ctx = new QueryContext();
-        const result = jsonbContainsBuilder(
-            { field: 'meta.tags', operator: 'CONTAINS', value: 'x' },
-            'c', ctx
-        );
-        expect(result.sql).toBe("c.data->'meta'->'tags' @> $1::jsonb");
-    });
-
-    test('numeric value', () => {
-        const ctx = new QueryContext();
-        jsonbContainsBuilder(
-            { field: 'scores', operator: 'CONTAINS', value: 42 },
-            'c', ctx
-        );
-        expect(ctx.params[0]).toEqual([42]);
-    });
-});
-
-describe('jsonbContainedByBuilder (<@)', () => {
-    test('generates correct SQL', () => {
-        const ctx = new QueryContext();
-        const result = jsonbContainedByBuilder(
-            { field: 'tags', operator: 'CONTAINED_BY', value: ['a', 'b', 'c'] },
-            'c', ctx
-        );
-        expect(result.sql).toBe("c.data->'tags' <@ $1::jsonb");
-        expect(ctx.params[0]).toEqual(['a', 'b', 'c']);
-        expect(result.addedParams).toBe(1);
-    });
-
-    test('single value is auto-wrapped', () => {
-        const ctx = new QueryContext();
-        jsonbContainedByBuilder(
-            { field: 'tags', operator: 'CONTAINED_BY', value: 'only' },
-            'c', ctx
-        );
-        expect(ctx.params[0]).toEqual(['only']);
-    });
-});
-
-describe('jsonbHasAnyBuilder (?|)', () => {
-    test('generates correct SQL with text[] cast', () => {
-        const ctx = new QueryContext();
-        const result = jsonbHasAnyBuilder(
-            { field: 'tags', operator: 'HAS_ANY', value: ['a', 'b'] },
-            'c', ctx
-        );
-        expect(result.sql).toBe("c.data->'tags' ?| $1::text[]");
-        expect(ctx.params[0]).toEqual(['a', 'b']);
-        expect(result.addedParams).toBe(1);
-    });
-
-    test('single value is auto-wrapped and stringified', () => {
-        const ctx = new QueryContext();
-        jsonbHasAnyBuilder(
-            { field: 'tags', operator: 'HAS_ANY', value: 'solo' },
-            'c', ctx
-        );
-        expect(ctx.params[0]).toEqual(['solo']);
-    });
-
-    test('numeric values are cast to strings', () => {
-        const ctx = new QueryContext();
-        jsonbHasAnyBuilder(
-            { field: 'ids', operator: 'HAS_ANY', value: [1, 2, 3] },
-            'c', ctx
-        );
-        expect(ctx.params[0]).toEqual(['1', '2', '3']);
-    });
-});
-
-describe('jsonbHasAllBuilder (?&)', () => {
-    test('generates correct SQL with text[] cast', () => {
-        const ctx = new QueryContext();
-        const result = jsonbHasAllBuilder(
-            { field: 'tags', operator: 'HAS_ALL', value: ['x', 'y'] },
-            'c', ctx
-        );
-        expect(result.sql).toBe("c.data->'tags' ?& $1::text[]");
-        expect(ctx.params[0]).toEqual(['x', 'y']);
-        expect(result.addedParams).toBe(1);
-    });
-});
-
-describe('validation', () => {
-    const validate = jsonbArrayOptions.validate!;
-
-    test('rejects null value', () => {
-        expect(validate({ field: 'f', operator: 'CONTAINS', value: null })).toBe(false);
-    });
-
-    test('rejects undefined value', () => {
-        expect(validate({ field: 'f', operator: 'CONTAINS', value: undefined })).toBe(false);
-    });
-
-    test('rejects empty array', () => {
-        expect(validate({ field: 'f', operator: 'CONTAINS', value: [] })).toBe(false);
-    });
-
-    test('accepts string value', () => {
-        expect(validate({ field: 'f', operator: 'CONTAINS', value: 'tag' })).toBe(true);
-    });
-
-    test('accepts number value', () => {
-        expect(validate({ field: 'f', operator: 'CONTAINS', value: 42 })).toBe(true);
-    });
-
-    test('accepts boolean value', () => {
-        expect(validate({ field: 'f', operator: 'CONTAINS', value: true })).toBe(true);
-    });
-
-    test('accepts array of strings', () => {
-        expect(validate({ field: 'f', operator: 'CONTAINS', value: ['a', 'b'] })).toBe(true);
-    });
-
-    test('rejects object value', () => {
-        expect(validate({ field: 'f', operator: 'CONTAINS', value: { key: 'val' } })).toBe(false);
-    });
-
-    test('rejects array with non-primitive elements', () => {
-        expect(validate({ field: 'f', operator: 'CONTAINS', value: [{ a: 1 }] })).toBe(false);
-    });
-});

package/tests/unit/query/Query.emptyString.test.ts

@@ -1,69 +0,0 @@
-/**
- * Empty-string filter support. JSONB text extraction (c.data->>'field')
- * returns text, so `= ''` / `!= ''` / LIKE against empty string are
- * legitimate. UUID-cast path is gated on a regex that empty cannot match.
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import { BaseComponent } from '../../../core/components/BaseComponent';
-import { Component, CompData } from '../../../core/components/Decorators';
-import { Query, FilterOp } from '../../../query/Query';
-import { ensureComponentsRegistered } from '../../utils';
-
-@Component
-class EmptyableNote extends BaseComponent {
-    @CompData()
-    value: string = '';
-}
-
-describe('Query empty-string filter', () => {
-    beforeAll(async () => {
-        await ensureComponentsRegistered(EmptyableNote);
-    });
-
-    test('Query.filter accepts empty-string value without throwing', () => {
-        expect(() => Query.filter('value', FilterOp.EQ, '')).not.toThrow();
-        const f = Query.filter('value', FilterOp.EQ, '');
-        expect(f.value).toBe('');
-    });
-
-    test('Query.filter accepts whitespace-only value without throwing', () => {
-        expect(() => Query.filter('value', FilterOp.EQ, '   ')).not.toThrow();
-    });
-
-    test('.with(C, filter EQ "") executes and returns matching rows', async () => {
-        const withEmpty = Entity.Create();
-        withEmpty.add(EmptyableNote, { value: '' });
-        await withEmpty.save();
-
-        const withData = Entity.Create();
-        withData.add(EmptyableNote, { value: 'not empty' });
-        await withData.save();
-
-        const rows = await new Query()
-            .with(EmptyableNote, Query.filters(Query.filter('value', FilterOp.EQ, '')))
-            .exec();
-
-        const ids = rows.map(e => e.id);
-        expect(ids).toContain(withEmpty.id);
-        expect(ids).not.toContain(withData.id);
-    });
-
-    test('.with(C, filter != "") excludes rows with empty value', async () => {
-        const withEmpty = Entity.Create();
-        withEmpty.add(EmptyableNote, { value: '' });
-        await withEmpty.save();
-
-        const withData = Entity.Create();
-        withData.add(EmptyableNote, { value: 'populated' });
-        await withData.save();
-
-        const rows = await new Query()
-            .with(EmptyableNote, Query.filters(Query.filter('value', FilterOp.NEQ, '')))
-            .exec();
-
-        const ids = rows.map(e => e.id);
-        expect(ids).toContain(withData.id);
-        expect(ids).not.toContain(withEmpty.id);
-    });
-});

package/tests/unit/query/Query.test.ts

@@ -1,310 +0,0 @@
-/**
- * Unit tests for Query class
- * Tests query builder methods and structure
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { Query, FilterOp } from '../../../query/Query';
-import { TestUser, TestProduct } from '../../fixtures/components';
-import { ensureComponentsRegistered } from '../../utils';
-
-describe('Query', () => {
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, TestProduct);
-    });
-
-    describe('constructor', () => {
-        test('creates a new query instance', () => {
-            const query = new Query();
-            expect(query).toBeDefined();
-        });
-
-        test('creates query with transaction', () => {
-            // Query accepts optional transaction parameter
-            const query = new Query();
-            expect(query).toBeDefined();
-        });
-    });
-
-    describe('findById()', () => {
-        test('sets up query to find by ID', () => {
-            const query = new Query();
-            const result = query.findById('test-id-123');
-            expect(result).toBe(query); // Returns this for chaining
-        });
-
-        test('throws for empty string id', () => {
-            const query = new Query();
-            expect(() => query.findById('')).toThrow();
-        });
-
-        test('throws for whitespace id', () => {
-            const query = new Query();
-            expect(() => query.findById('   ')).toThrow();
-        });
-    });
-
-    describe('with()', () => {
-        test('adds component requirement to query', () => {
-            const query = new Query();
-            const result = query.with(TestUser);
-            // with() returns same instance for chaining (type changes for type accumulation)
-            expect(result as any).toBe(query as any);
-        });
-
-        test('allows chaining multiple with() calls', () => {
-            const query = new Query();
-            const result = query.with(TestUser).with(TestProduct);
-            expect(result as any).toBe(query as any);
-        });
-
-        test('accepts component with filters', () => {
-            const query = new Query();
-            const result = query.with(TestUser, {
-                filters: [{ field: 'name', operator: FilterOp.EQ, value: 'John' }]
-            });
-            expect(result as any).toBe(query as any);
-        });
-
-        test('accepts array of components with filters', () => {
-            const query = new Query();
-            const result = query.with([
-                { component: TestUser, filters: [{ field: 'age', operator: FilterOp.GT, value: 18 }] },
-                { component: TestProduct, filters: [{ field: 'price', operator: FilterOp.LT, value: 100 }] }
-            ]);
-            expect(result).toBe(query);
-        });
-    });
-
-    describe('without()', () => {
-        test('excludes entities with specified component', () => {
-            const query = new Query();
-            const result = query.with(TestUser).without(TestProduct);
-            expect(result as any).toBe(query as any);
-        });
-    });
-
-    describe('excludeEntityId()', () => {
-        test('excludes specific entity from results', () => {
-            const query = new Query();
-            const result = query.excludeEntityId('entity-to-exclude');
-            expect(result).toBe(query);
-        });
-    });
-
-    describe('populate()', () => {
-        test('enables component population', () => {
-            const query = new Query();
-            const result = query.with(TestUser).populate();
-            expect(result as any).toBe(query as any);
-        });
-    });
-
-    describe('eagerLoadComponents()', () => {
-        test('sets up eager loading for components', () => {
-            const query = new Query();
-            const result = query.with(TestUser).eagerLoadComponents([TestUser, TestProduct]);
-            expect(result as any).toBe(query as any);
-        });
-    });
-
-    describe('eagerLoad()', () => {
-        test('is an alias for eagerLoadComponents', () => {
-            const query = new Query();
-            const result = query.with(TestUser).eagerLoad([TestUser]);
-            expect(result as any).toBe(query as any);
-        });
-    });
-
-    describe('take()', () => {
-        test('sets limit on query results', () => {
-            const query = new Query();
-            const result = query.with(TestUser).take(10);
-            expect(result as any).toBe(query as any);
-        });
-    });
-
-    describe('offset()', () => {
-        test('sets offset for pagination', () => {
-            const query = new Query();
-            const result = query.with(TestUser).offset(20);
-            expect(result as any).toBe(query as any);
-        });
-    });
-
-    describe('sortBy()', () => {
-        test('sets sort order', () => {
-            const query = new Query();
-            const result = query.with(TestUser).sortBy(TestUser, 'name', 'ASC');
-            expect(result as any).toBe(query as any);
-        });
-
-        test('accepts DESC direction', () => {
-            const query = new Query();
-            const result = query.with(TestUser).sortBy(TestUser, 'age', 'DESC');
-            expect(result as any).toBe(query as any);
-        });
-
-        test('accepts nullsFirst option', () => {
-            const query = new Query();
-            const result = query.with(TestUser).sortBy(TestUser, 'bio', 'ASC', true);
-            expect(result as any).toBe(query as any);
-        });
-
-        test('throws if component not in query', () => {
-            const query = new Query();
-            expect(() => query.sortBy(TestUser, 'name')).toThrow();
-        });
-    });
-
-    describe('debugMode()', () => {
-        test('enables debug mode', () => {
-            const query = new Query();
-            const result = query.debugMode(true);
-            expect(result).toBe(query);
-        });
-
-        test('can disable debug mode', () => {
-            const query = new Query();
-            const result = query.debugMode(false);
-            expect(result).toBe(query);
-        });
-    });
-
-    describe('noCache()', () => {
-        test('bypasses prepared statement cache by default', () => {
-            const query = new Query();
-            const result = query.noCache();
-            expect(result).toBe(query);
-        });
-
-        test('accepts cache options', () => {
-            const query = new Query();
-            const result = query.noCache({ preparedStatement: true, component: true });
-            expect(result).toBe(query);
-        });
-    });
-
-    describe('filter()', () => {
-        test('creates filter object', () => {
-            const filter = Query.filter('name', FilterOp.EQ, 'John');
-            expect(filter.field).toBe('name');
-            expect(filter.operator).toBe(FilterOp.EQ);
-            expect(filter.value).toBe('John');
-        });
-
-        test('accepts empty string value', () => {
-            const filter = Query.filter('name', FilterOp.EQ, '');
-            expect(filter.value).toBe('');
-        });
-
-        test('accepts whitespace value', () => {
-            const filter = Query.filter('name', FilterOp.EQ, '   ');
-            expect(filter.value).toBe('   ');
-        });
-    });
-
-    describe('typedFilter()', () => {
-        test('creates typed filter object', () => {
-            const filter = Query.typedFilter(TestUser, 'name', FilterOp.EQ, 'John');
-            expect(filter.field).toBe('name');
-            expect(filter.operator).toBe(FilterOp.EQ);
-            expect(filter.value).toBe('John');
-        });
-    });
-
-    describe('filters()', () => {
-        test('creates filter options from multiple filters', () => {
-            const filter1 = Query.filter('name', FilterOp.EQ, 'John');
-            const filter2 = Query.filter('age', FilterOp.GT, 18);
-            const options = Query.filters(filter1, filter2);
-
-            expect(options.filters).toBeDefined();
-            expect(options.filters?.length).toBe(2);
-        });
-    });
-
-    describe('FilterOp', () => {
-        test('has all expected operators', () => {
-            expect(FilterOp.EQ).toBeDefined();
-            expect(FilterOp.NEQ).toBeDefined();
-            expect(FilterOp.GT).toBeDefined();
-            expect(FilterOp.GTE).toBeDefined();
-            expect(FilterOp.LT).toBeDefined();
-            expect(FilterOp.LTE).toBeDefined();
-            expect(FilterOp.LIKE).toBeDefined();
-            expect(FilterOp.IN).toBeDefined();
-            expect(FilterOp.NOT_IN).toBeDefined();
-        });
-    });
-
-    describe('chaining', () => {
-        test('supports full query chain', () => {
-            const query = new Query()
-                .with(TestUser, { filters: [Query.filter('age', FilterOp.GTE, 18)] })
-                .with(TestProduct)
-                .without(TestProduct)
-                .take(10)
-                .offset(0)
-                .sortBy(TestUser, 'name')
-                .populate()
-                .debugMode(false)
-                .noCache();
-
-            expect(query).toBeDefined();
-        });
-    });
-
-    describe('sum()', () => {
-        test('throws if component not in query', async () => {
-            const query = new Query();
-            // TestProduct not added via .with()
-            await expect(query.sum(TestProduct, 'price')).rejects.toThrow(
-                /not included in the query/
-            );
-        });
-
-        test('throws if component is not registered', async () => {
-            class UnregisteredComponent {
-                value!: number;
-            }
-            const query = new Query();
-            // @ts-expect-error - Testing with unregistered component
-            await expect(query.sum(UnregisteredComponent, 'value')).rejects.toThrow(
-                /not registered/
-            );
-        });
-
-        test('returns a Promise', () => {
-            const query = new Query().with(TestProduct);
-            const result = query.sum(TestProduct, 'price');
-            expect(result).toBeInstanceOf(Promise);
-        });
-    });
-
-    describe('average()', () => {
-        test('throws if component not in query', async () => {
-            const query = new Query();
-            // TestProduct not added via .with()
-            await expect(query.average(TestProduct, 'price')).rejects.toThrow(
-                /not included in the query/
-            );
-        });
-
-        test('throws if component is not registered', async () => {
-            class UnregisteredComponent {
-                value!: number;
-            }
-            const query = new Query();
-            // @ts-expect-error - Testing with unregistered component
-            await expect(query.average(UnregisteredComponent, 'value')).rejects.toThrow(
-                /not registered/
-            );
-        });
-
-        test('returns a Promise', () => {
-            const query = new Query().with(TestProduct);
-            const result = query.average(TestProduct, 'price');
-            expect(result).toBeInstanceOf(Promise);
-        });
-    });
-});