@enspirit/bmg-js 1.0.0 → 1.0.2

package/tests/operators/transform.test.ts

@@ -1,94 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { transform, isEqual } from 'src/operators';
-
-describe('.transform', () => {
-
-  it('applies a function to all attribute values', () => {
-    const data = Bmg([
-      { id: 1, value: 10 },
-      { id: 2, value: 20 },
-    ]);
-    const result = data.transform(String);
-    const expected = Bmg([
-      { id: '1', value: '10' },
-      { id: '2', value: '20' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('applies specific functions to named attributes', () => {
-    const data = Bmg([
-      { name: 'alice', status: 10, city: 'NYC' },
-      { name: 'bob', status: 20, city: 'LA' },
-    ]);
-    const result = data.transform({
-      name: (v) => (v as string).toUpperCase(),
-      status: (v) => (v as number) * 2
-    });
-    const expected = Bmg([
-      { name: 'ALICE', status: 20, city: 'NYC' },
-      { name: 'BOB', status: 40, city: 'LA' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('chains multiple transformations with array', () => {
-    const data = Bmg([
-      { id: 1, value: 10 },
-      { id: 2, value: 20 },
-    ]);
-    const result = data.transform([
-      String,
-      (v) => `[${v}]`
-    ]);
-    const expected = Bmg([
-      { id: '[1]', value: '[10]' },
-      { id: '[2]', value: '[20]' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('chains per-attribute transformations', () => {
-    const data = Bmg([
-      { name: 'Alice' },
-      { name: 'Bob' },
-    ]);
-    const result = data.transform({
-      name: [(v) => (v as string).toLowerCase(), (v) => (v as string).toUpperCase()]
-    });
-    const expected = Bmg([
-      { name: 'ALICE' },
-      { name: 'BOB' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('leaves attributes without transformers unchanged', () => {
-    const data = Bmg([
-      { id: 1, name: 'alice', status: 10 },
-      { id: 2, name: 'bob', status: 20 },
-    ]);
-    const result = data.transform({
-      name: (v) => (v as string).toUpperCase()
-    });
-    const expected = Bmg([
-      { id: 1, name: 'ALICE', status: 10 },
-      { id: 2, name: 'BOB', status: 20 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const data = Bmg([
-      { name: 'alice', value: 10 },
-      { name: 'bob', value: 20 },
-    ]);
-    const standalone = transform(data.toArray(), { name: (v) => (v as string).toUpperCase() });
-    const expected = data.transform({ name: (v) => (v as string).toUpperCase() });
-    expect(isEqual(standalone, expected)).to.be.true;
-  })
-
-});

package/tests/operators/ungroup.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { ungroup , isEqual } from 'src/operators';
-
-describe('.ungroup', () => {
-
-  const grouped = Bmg([
-    {
-      order_id: 1,
-      customer: 'Alice',
-      items: [
-        { item: 'Apple', qty: 2 },
-        { item: 'Banana', qty: 3 },
-      ]
-    },
-    {
-      order_id: 2,
-      customer: 'Bob',
-      items: [
-        { item: 'Cherry', qty: 1 },
-      ]
-    },
-  ]);
-
-  it('flattens nested relation into parent tuples', () => {
-    const result = grouped.ungroup('items');
-    const expected = Bmg([
-      { order_id: 1, customer: 'Alice', item: 'Apple', qty: 2 },
-      { order_id: 1, customer: 'Alice', item: 'Banana', qty: 3 },
-      { order_id: 2, customer: 'Bob', item: 'Cherry', qty: 1 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('preserves parent attributes', () => {
-    const result = grouped.ungroup('items') as any;
-    const appleRow = result.restrict({ item: 'Apple' }).one();
-    expect(appleRow.order_id).to.eql(1);
-    expect(appleRow.customer).to.eql('Alice');
-  })
-
-  it('merges nested attributes', () => {
-    const result = grouped.ungroup('items') as any;
-    const appleRow = result.restrict({ item: 'Apple' }).one();
-    expect(appleRow.item).to.eql('Apple');
-    expect(appleRow.qty).to.eql(2);
-  })
-
-  it('is the inverse of group', () => {
-    const orders = Bmg([
-      { order_id: 1, customer: 'Alice', item: 'Apple', qty: 2 },
-      { order_id: 1, customer: 'Alice', item: 'Banana', qty: 3 },
-      { order_id: 2, customer: 'Bob', item: 'Cherry', qty: 1 },
-    ]);
-    const roundtrip = orders.group(['item', 'qty'], 'items').ungroup('items');
-    expect(roundtrip.isEqual(orders)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = ungroup(grouped.toArray(), 'items');
-    const expected = grouped.ungroup('items');
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/union.test.ts

@@ -1,51 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { union , isEqual } from 'src/operators';
-
-describe('.union', () => {
-
-  const left = Bmg([
-    { id: 1, name: 'Alice' },
-    { id: 2, name: 'Bob' },
-  ]);
-
-  const right = Bmg([
-    { id: 2, name: 'Bob' },
-    { id: 3, name: 'Charlie' },
-  ]);
-
-  it('combines tuples from both relations', () => {
-    const result = left.union(right);
-    const expected = Bmg([
-      { id: 1, name: 'Alice' },
-      { id: 2, name: 'Bob' },
-      { id: 3, name: 'Charlie' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('removes duplicates', () => {
-    const result = left.union(right);
-    const expected = Bmg([
-      { id: 1, name: 'Alice' },
-      { id: 2, name: 'Bob' },
-      { id: 3, name: 'Charlie' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('is commutative (set semantics)', () => {
-    const lr = left.union(right);
-    const rl = right.union(left);
-    expect(lr.isEqual(rl)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = union(left.toArray(), right.toArray());
-    const expected = left.union(right);
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/unwrap.test.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { SUPPLIERS } from 'tests/fixtures';
-import { unwrap , isEqual } from 'src/operators';
-
-describe('.unwrap', () => {
-
-  const wrapped = Bmg([
-    { sid: 'S1', name: 'Smith', details: { status: 20, city: 'London' } },
-    { sid: 'S2', name: 'Jones', details: { status: 10, city: 'Paris' } },
-  ]);
-
-  it('flattens tuple-valued attribute', () => {
-    const result = wrapped.unwrap('details');
-    const expected = Bmg([
-      { sid: 'S1', name: 'Smith', status: 20, city: 'London' },
-      { sid: 'S2', name: 'Jones', status: 10, city: 'Paris' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('removes the wrapped attribute', () => {
-    const result = wrapped.unwrap('details');
-    const smith = result.restrict({ sid: 'S1' }).one();
-    expect(smith).to.not.have.property('details');
-  })
-
-  it('is the inverse of wrap', () => {
-    const roundtrip = SUPPLIERS.wrap(['status', 'city'], 'details').unwrap('details');
-    expect(roundtrip.isEqual(SUPPLIERS)).to.be.true;
-  })
-
-  it('handles deeply nested unwrap', () => {
-    const nested = Bmg([
-      { id: 1, outer: { inner: { value: 42 } } }
-    ]);
-    const result = nested.unwrap('outer');
-    const expected = Bmg([{ id: 1, inner: { value: 42 } }]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = unwrap(wrapped.toArray(), 'details');
-    const expected = wrapped.unwrap('details');
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/where.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import { SUPPLIERS } from 'tests/fixtures';
-import { where , isEqual } from 'src/operators';
-
-describe('.where', () => {
-
-  it('allows filtering relations (alias for restrict)', () => {
-    const smith = SUPPLIERS.where((t) => t.sid === 'S1').one()
-    expect(smith.name).to.eql('Smith')
-  })
-
-  it('has a tuple shortcut', () => {
-    const smith = SUPPLIERS.where({sid: 'S1'}).one()
-    expect(smith.name).to.eql('Smith')
-  })
-
-  it('returns same result as restrict', () => {
-    const withWhere = SUPPLIERS.where({city: 'Paris'});
-    const withRestrict = SUPPLIERS.restrict({city: 'Paris'});
-    expect(withWhere.isEqual(withRestrict)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const input = SUPPLIERS.toArray();
-    const res = where(input, { sid: 'S1' });
-    const expected = SUPPLIERS.where({ sid: 'S1' });
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/wrap.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { SUPPLIERS } from 'tests/fixtures';
-import { wrap , isEqual } from 'src/operators';
-
-describe('.wrap', () => {
-
-  it('wraps specified attributes into a tuple', () => {
-    const result = SUPPLIERS.wrap(['status', 'city'], 'details');
-    const expected = Bmg([
-      { sid: 'S1', name: 'Smith', details: { status: 20, city: 'London' } },
-      { sid: 'S2', name: 'Jones', details: { status: 10, city: 'Paris' } },
-      { sid: 'S3', name: 'Blake', details: { status: 30, city: 'Paris' } },
-      { sid: 'S4', name: 'Clark', details: { status: 20, city: 'London' } },
-      { sid: 'S5', name: 'Adams', details: { status: 30, city: 'Athens' } },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('preserves non-wrapped attributes', () => {
-    const result = SUPPLIERS.wrap(['status', 'city'], 'details');
-    const smith = result.restrict({ sid: 'S1' }).one();
-    expect(smith.sid).to.eql('S1');
-    expect(smith.name).to.eql('Smith');
-    expect(Object.keys(smith).sort()).to.eql(['details', 'name', 'sid']);
-  })
-
-  it('handles wrapping all attributes', () => {
-    const result = SUPPLIERS.wrap(['sid', 'name', 'status', 'city'], 'all');
-    const expected = Bmg([
-      { all: { sid: 'S1', name: 'Smith', status: 20, city: 'London' } },
-      { all: { sid: 'S2', name: 'Jones', status: 10, city: 'Paris' } },
-      { all: { sid: 'S3', name: 'Blake', status: 30, city: 'Paris' } },
-      { all: { sid: 'S4', name: 'Clark', status: 20, city: 'London' } },
-      { all: { sid: 'S5', name: 'Adams', status: 30, city: 'Athens' } },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('handles wrapping single attribute', () => {
-    const result = SUPPLIERS.wrap(['city'], 'location');
-    const smith = result.restrict({ sid: 'S1' }).one();
-    expect(smith.location).to.eql({ city: 'London' });
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = wrap(SUPPLIERS.toArray(), ['status', 'city'], 'details');
-    const expected = SUPPLIERS.wrap(['status', 'city'], 'details');
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/yByX.test.ts

@@ -1,32 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { SUPPLIERS } from 'tests/fixtures';
-import { yByX } from 'src/operators';
-
-describe('.yByX', () => {
-
-  it('is available on relations', () => {
-    expect(SUPPLIERS.yByX('name', 'sid')).to.eql({
-      'S1': 'Smith',
-      'S2': 'Jones',
-      'S3': 'Blake',
-      'S4': 'Clark',
-      'S5': 'Adams',
-    })
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const tuples = [
-      {sid: 'S1', name: 'Smith'},
-      {sid: 'S2', name: 'Jones'},
-    ]
-    expect(yByX(tuples, 'name', 'sid')).to.eql(
-      {
-        'S1': 'Smith',
-        'S2': 'Jones',
-      }
-    )
-  })
-
-});

package/tests/types/relation.test.ts

@@ -1,296 +0,0 @@
-/**
- * Type-level tests for the generic Relation<T> system.
- * These tests verify compile-time type safety.
- */
-import { describe, it, expectTypeOf } from 'vitest';
-import { Bmg } from 'src';
-import type { Relation, Tuple } from 'src/types';
-
-// Define a typed interface for testing
-interface Person {
-  id: number;
-  name: string;
-  age: number;
-  city: string;
-}
-
-interface Order {
-  orderId: number;
-  customerId: number;
-  total: number;
-}
-
-describe('Type Safety', () => {
-
-  describe('Bmg factory', () => {
-    it('infers type from input array', () => {
-      const r = Bmg([{ id: 1, name: 'Alice' }]);
-      expectTypeOf(r.one()).toMatchTypeOf<{ id: number; name: string }>();
-    });
-
-    it('accepts explicit type parameter', () => {
-      const r = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      expectTypeOf(r).toMatchTypeOf<Relation<Person>>();
-    });
-
-    it('returns untyped Relation when no type info', () => {
-      const data: Tuple[] = [{ a: 1 }];
-      const r = Bmg(data);
-      expectTypeOf(r).toMatchTypeOf<Relation<Tuple>>();
-    });
-  });
-
-  describe('one() and toArray()', () => {
-    it('returns typed tuple from one()', () => {
-      const r = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      const tuple = r.one();
-      expectTypeOf(tuple.id).toBeNumber();
-      expectTypeOf(tuple.name).toBeString();
-      expectTypeOf(tuple.age).toBeNumber();
-    });
-
-    it('returns typed array from toArray()', () => {
-      const r = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      const arr = r.toArray();
-      expectTypeOf(arr).toMatchTypeOf<Person[]>();
-    });
-  });
-
-  describe('project()', () => {
-    it('narrows type to selected attributes', () => {
-      const r = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      const projected = r.project(['id', 'name']);
-      expectTypeOf(projected.one()).toMatchTypeOf<{ id: number; name: string }>();
-    });
-
-    it('accepts valid attribute names only', () => {
-      const r = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      // This should compile - valid attributes
-      r.project(['id', 'name']);
-
-      // @ts-expect-error - 'invalid' is not a valid attribute
-      r.project(['invalid']);
-    });
-  });
-
-  describe('allbut()', () => {
-    it('removes specified attributes from type', () => {
-      const r = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      const result = r.allbut(['age', 'city']);
-      expectTypeOf(result.one()).toMatchTypeOf<{ id: number; name: string }>();
-    });
-  });
-
-  describe('restrict/where/exclude', () => {
-    it('preserves type through restrict', () => {
-      const r = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      const filtered = r.restrict({ city: 'NYC' });
-      expectTypeOf(filtered.one()).toMatchTypeOf<Person>();
-    });
-
-    it('provides typed tuple in predicate function', () => {
-      const r = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      r.restrict(t => {
-        expectTypeOf(t.age).toBeNumber();
-        return t.age > 25;
-      });
-    });
-
-    it('where is alias for restrict', () => {
-      const r = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      const filtered = r.where(t => t.age > 25);
-      expectTypeOf(filtered).toMatchTypeOf<Relation<Person>>();
-    });
-  });
-
-  describe('rename()', () => {
-    it('transforms attribute names in type', () => {
-      const r = Bmg<{ name: string; age: number }>([{ name: 'Alice', age: 30 }]);
-      const renamed = r.rename({ name: 'fullName' });
-      const tuple = renamed.one();
-      // Check individual properties since mapped types can be tricky for toMatchTypeOf
-      expectTypeOf(tuple.fullName).toBeString();
-      expectTypeOf(tuple.age).toBeNumber();
-    });
-  });
-
-  describe('extend()', () => {
-    it('adds new attributes to type', () => {
-      const r = Bmg<{ id: number; age: number }>([{ id: 1, age: 30 }]);
-      const extended = r.extend({
-        senior: (t) => t.age >= 65,
-        label: (t) => `Person ${t.id}`
-      });
-      const tuple = extended.one();
-      expectTypeOf(tuple.id).toBeNumber();
-      expectTypeOf(tuple.age).toBeNumber();
-      expectTypeOf(tuple.senior).toBeBoolean();
-      expectTypeOf(tuple.label).toBeString();
-    });
-  });
-
-  describe('constants()', () => {
-    it('adds constant attributes to type', () => {
-      const r = Bmg<{ id: number }>([{ id: 1 }]);
-      const result = r.constants({ version: 1, active: true });
-      const tuple = result.one();
-      expectTypeOf(tuple.id).toBeNumber();
-      expectTypeOf(tuple.version).toBeNumber();
-      expectTypeOf(tuple.active).toBeBoolean();
-    });
-  });
-
-  describe('join()', () => {
-    it('combines types from both relations', () => {
-      const people = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      // Use array to avoid variance issues with Relation<Order> vs Relation<Tuple>
-      const orders: Order[] = [{ orderId: 100, customerId: 1, total: 50 }];
-
-      const joined = people.join(orders, { id: 'customerId' });
-      const tuple = joined.one();
-
-      // Should have all Person attributes
-      expectTypeOf(tuple.id).toBeNumber();
-      expectTypeOf(tuple.name).toBeString();
-      expectTypeOf(tuple.age).toBeNumber();
-
-      // Should have Order attributes (minus the join key)
-      expectTypeOf(tuple.orderId).toBeNumber();
-      expectTypeOf(tuple.total).toBeNumber();
-    });
-  });
-
-  describe('cross_product()', () => {
-    it('combines all attributes from both relations', () => {
-      const r1 = Bmg<{ a: number }>([{ a: 1 }]);
-      const r2 = Bmg<{ b: string }>([{ b: 'x' }]);
-
-      const product = r1.cross_product(r2);
-      const tuple = product.one();
-
-      expectTypeOf(tuple.a).toBeNumber();
-      expectTypeOf(tuple.b).toBeString();
-    });
-  });
-
-  describe('union/minus/intersect', () => {
-    it('preserves type in set operations', () => {
-      const r1 = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      const r2 = Bmg<Person>([{ id: 2, name: 'Bob', age: 25, city: 'LA' }]);
-
-      expectTypeOf(r1.union(r2)).toMatchTypeOf<Relation<Person>>();
-      expectTypeOf(r1.minus(r2)).toMatchTypeOf<Relation<Person>>();
-      expectTypeOf(r1.intersect(r2)).toMatchTypeOf<Relation<Person>>();
-    });
-  });
-
-  describe('matching/not_matching', () => {
-    it('preserves left type in semi-joins', () => {
-      const people = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-      // Use array to avoid variance issues with Relation<Order> vs Relation<Tuple>
-      const orders: Order[] = [{ orderId: 100, customerId: 1, total: 50 }];
-
-      const matched = people.matching(orders, { id: 'customerId' });
-      expectTypeOf(matched).toMatchTypeOf<Relation<Person>>();
-
-      const notMatched = people.not_matching(orders, { id: 'customerId' });
-      expectTypeOf(notMatched).toMatchTypeOf<Relation<Person>>();
-    });
-  });
-
-  describe('group()', () => {
-    it('creates nested relation type', () => {
-      const r = Bmg<{ orderId: number; item: string; qty: number }>([
-        { orderId: 1, item: 'A', qty: 10 }
-      ]);
-
-      const grouped = r.group(['item', 'qty'], 'items');
-      const tuple = grouped.one();
-
-      expectTypeOf(tuple.orderId).toBeNumber();
-      // items should be a Relation of the grouped attributes
-      expectTypeOf(tuple.items).toMatchTypeOf<Relation<{ item: string; qty: number }>>();
-    });
-  });
-
-  describe('wrap()', () => {
-    it('creates nested object type', () => {
-      const r = Bmg<{ id: number; street: string; city: string }>([
-        { id: 1, street: '123 Main', city: 'NYC' }
-      ]);
-
-      const wrapped = r.wrap(['street', 'city'], 'address');
-      const tuple = wrapped.one();
-
-      expectTypeOf(tuple.id).toBeNumber();
-      expectTypeOf(tuple.address).toMatchTypeOf<{ street: string; city: string }>();
-    });
-  });
-
-  describe('prefix/suffix', () => {
-    it('transforms attribute names with prefix', () => {
-      const r = Bmg<{ id: number; name: string }>([{ id: 1, name: 'Alice' }]);
-      const prefixed = r.prefix('user_');
-      const tuple = prefixed.one();
-
-      expectTypeOf(tuple).toMatchTypeOf<{ user_id: number; user_name: string }>();
-    });
-
-    it('transforms attribute names with suffix', () => {
-      const r = Bmg<{ id: number; name: string }>([{ id: 1, name: 'Alice' }]);
-      const suffixed = r.suffix('_val');
-      const tuple = suffixed.one();
-
-      expectTypeOf(tuple).toMatchTypeOf<{ id_val: number; name_val: string }>();
-    });
-  });
-
-  describe('yByX()', () => {
-    it('returns correctly typed record', () => {
-      const r = Bmg<{ id: number; name: string }>([
-        { id: 1, name: 'Alice' },
-        { id: 2, name: 'Bob' }
-      ]);
-
-      const byId = r.yByX('name', 'id');
-      expectTypeOf(byId).toMatchTypeOf<Record<number, string>>();
-    });
-  });
-
-  describe('transform()', () => {
-    it('preserves type structure', () => {
-      const r = Bmg<{ id: number; name: string }>([{ id: 1, name: 'Alice' }]);
-      const transformed = r.transform({ name: v => (v as string).toUpperCase() });
-      expectTypeOf(transformed).toMatchTypeOf<Relation<{ id: number; name: string }>>();
-    });
-  });
-
-  describe('autowrap()', () => {
-    it('returns untyped Relation (dynamic)', () => {
-      const r = Bmg<{ id: number; user_name: string; user_email: string }>([
-        { id: 1, user_name: 'Alice', user_email: 'alice@test.com' }
-      ]);
-
-      const autowrapped = r.autowrap();
-      // autowrap loses type information (dynamic structure)
-      expectTypeOf(autowrapped).toMatchTypeOf<Relation<Tuple>>();
-    });
-  });
-
-  describe('method chaining', () => {
-    it('preserves types through operator chain', () => {
-      const r = Bmg<Person>([{ id: 1, name: 'Alice', age: 30, city: 'NYC' }]);
-
-      const result = r
-        .restrict(t => t.age > 25)
-        .project(['id', 'name'])
-        .rename({ name: 'fullName' });
-
-      const tuple = result.one();
-      // Check individual properties since mapped types can be tricky for toMatchTypeOf
-      expectTypeOf(tuple.id).toBeNumber();
-      expectTypeOf(tuple.fullName).toBeString();
-    });
-  });
-
-});