@enspirit/bmg-js 1.0.0 → 1.0.2

package/tests/operators/left_join.test.ts

@@ -1,116 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { left_join , isEqual } from 'src/operators';
-
-describe('.left_join', () => {
-
-  const orders = Bmg([
-    { oid: 1, customer_id: 'C1', amount: 100 },
-    { oid: 2, customer_id: 'C2', amount: 200 },
-    { oid: 3, customer_id: 'C3', amount: 150 },
-  ]);
-
-  const customers = Bmg([
-    { customer_id: 'C1', name: 'Alice' },
-    { customer_id: 'C2', name: 'Bob' },
-  ]);
-
-  it('joins matching tuples and keeps non-matching with null', () => {
-    const result = orders.left_join(customers);
-    const expected = Bmg([
-      { oid: 1, customer_id: 'C1', amount: 100, name: 'Alice' },
-      { oid: 2, customer_id: 'C2', amount: 200, name: 'Bob' },
-      { oid: 3, customer_id: 'C3', amount: 150, name: null },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports explicit keys as { left: right }', () => {
-    const suppliers = Bmg([
-      { sid: 'S1', city: 'London' },
-      { sid: 'S2', city: 'Paris' },
-      { sid: 'S3', city: 'Athens' },
-    ]);
-    const cities = Bmg([
-      { location: 'London', country: 'UK' },
-      { location: 'Paris', country: 'France' },
-    ]);
-    const result = suppliers.left_join(cities, { city: 'location' });
-    const expected = Bmg([
-      { sid: 'S1', city: 'London', country: 'UK' },
-      { sid: 'S2', city: 'Paris', country: 'France' },
-      { sid: 'S3', city: 'Athens', country: null },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports explicit keys as [common_attr]', () => {
-    const result = orders.left_join(customers, ['customer_id']);
-    const expected = Bmg([
-      { oid: 1, customer_id: 'C1', amount: 100, name: 'Alice' },
-      { oid: 2, customer_id: 'C2', amount: 200, name: 'Bob' },
-      { oid: 3, customer_id: 'C3', amount: 150, name: null },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports multiple keys as [attr1, attr2]', () => {
-    const inventory = Bmg([
-      { warehouse: 'W1', city: 'London', stock: 100 },
-      { warehouse: 'W2', city: 'London', stock: 200 },
-      { warehouse: 'W1', city: 'Paris', stock: 150 },
-    ]);
-    const shipments = Bmg([
-      { warehouse: 'W1', city: 'London', shipped: 50 },
-    ]);
-    const result = inventory.left_join(shipments, ['warehouse', 'city']);
-    const expected = Bmg([
-      { warehouse: 'W1', city: 'London', stock: 100, shipped: 50 },
-      { warehouse: 'W2', city: 'London', stock: 200, shipped: null },
-      { warehouse: 'W1', city: 'Paris', stock: 150, shipped: null },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports multiple keys as { left1: right1, left2: right2 }', () => {
-    const people = Bmg([
-      { id: 1, first: 'John', last: 'Doe' },
-      { id: 2, first: 'Jane', last: 'Smith' },
-      { id: 3, first: 'John', last: 'Smith' },
-    ]);
-    const records = Bmg([
-      { fname: 'John', lname: 'Doe', score: 85 },
-      { fname: 'Jane', lname: 'Smith', score: 90 },
-    ]);
-    const result = people.left_join(records, { first: 'fname', last: 'lname' });
-    const expected = Bmg([
-      { id: 1, first: 'John', last: 'Doe', score: 85 },
-      { id: 2, first: 'Jane', last: 'Smith', score: 90 },
-      { id: 3, first: 'John', last: 'Smith', score: null },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('handles multiple matches', () => {
-    const left = Bmg([{ id: 1, city: 'Paris' }]);
-    const right = Bmg([
-      { city: 'Paris', name: 'A' },
-      { city: 'Paris', name: 'B' },
-    ]);
-    const result = left.left_join(right);
-    const expected = Bmg([
-      { id: 1, city: 'Paris', name: 'A' },
-      { id: 1, city: 'Paris', name: 'B' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = left_join(orders.toArray(), customers.toArray());
-    const expected = orders.left_join(customers);
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/matching.test.ts

@@ -1,91 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { matching , isEqual } from 'src/operators';
-
-describe('.matching', () => {
-
-  const orders = Bmg([
-    { oid: 1, customer_id: 'C1', amount: 100 },
-    { oid: 2, customer_id: 'C2', amount: 200 },
-    { oid: 3, customer_id: 'C3', amount: 150 },
-  ]);
-
-  const customers = Bmg([
-    { customer_id: 'C1', name: 'Alice' },
-    { customer_id: 'C2', name: 'Bob' },
-  ]);
-
-  it('returns tuples from left that match right on common attrs', () => {
-    const result = orders.matching(customers);
-    const expected = Bmg([
-      { oid: 1, customer_id: 'C1', amount: 100 },
-      { oid: 2, customer_id: 'C2', amount: 200 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports explicit keys as [common_attr]', () => {
-    const result = orders.matching(customers, ['customer_id']);
-    const expected = Bmg([
-      { oid: 1, customer_id: 'C1', amount: 100 },
-      { oid: 2, customer_id: 'C2', amount: 200 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports multiple keys as [attr1, attr2]', () => {
-    const inventory = Bmg([
-      { warehouse: 'W1', city: 'London', stock: 100 },
-      { warehouse: 'W2', city: 'London', stock: 200 },
-      { warehouse: 'W1', city: 'Paris', stock: 150 },
-    ]);
-    const shipments = Bmg([
-      { warehouse: 'W1', city: 'London' },
-      { warehouse: 'W1', city: 'Paris' },
-    ]);
-    const result = inventory.matching(shipments, ['warehouse', 'city']);
-    const expected = Bmg([
-      { warehouse: 'W1', city: 'London', stock: 100 },
-      { warehouse: 'W1', city: 'Paris', stock: 150 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports explicit keys as { left: right }', () => {
-    const suppliers = Bmg([
-      { sid: 'S1', city: 'London' },
-      { sid: 'S2', city: 'Paris' },
-    ]);
-    const cities = Bmg([{ location: 'London' }]);
-    const result = suppliers.matching(cities, { city: 'location' });
-    const expected = Bmg([{ sid: 'S1', city: 'London' }]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports multiple keys as { left1: right1, left2: right2 }', () => {
-    const people = Bmg([
-      { id: 1, first: 'John', last: 'Doe' },
-      { id: 2, first: 'Jane', last: 'Smith' },
-      { id: 3, first: 'John', last: 'Smith' },
-    ]);
-    const records = Bmg([
-      { fname: 'John', lname: 'Doe' },
-      { fname: 'Jane', lname: 'Smith' },
-    ]);
-    const result = people.matching(records, { first: 'fname', last: 'lname' });
-    const expected = Bmg([
-      { id: 1, first: 'John', last: 'Doe' },
-      { id: 2, first: 'Jane', last: 'Smith' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = matching(orders.toArray(), customers.toArray());
-    const expected = orders.matching(customers);
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/minus.test.ts

@@ -1,47 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { minus , isEqual } from 'src/operators';
-
-describe('.minus', () => {
-
-  const left = Bmg([
-    { id: 1, name: 'Alice' },
-    { id: 2, name: 'Bob' },
-    { id: 3, name: 'Charlie' },
-  ]);
-
-  const right = Bmg([
-    { id: 2, name: 'Bob' },
-    { id: 4, name: 'Diana' },
-  ]);
-
-  it('returns tuples in left but not in right', () => {
-    const result = left.minus(right);
-    const expected = Bmg([
-      { id: 1, name: 'Alice' },
-      { id: 3, name: 'Charlie' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('returns empty when left is subset of right', () => {
-    const small = Bmg([{ id: 2, name: 'Bob' }]);
-    const result = small.minus(right);
-    expect(result.isEqual(Bmg([]))).to.be.true;
-  })
-
-  it('returns all when no overlap', () => {
-    const other = Bmg([{ id: 99, name: 'Nobody' }]);
-    const result = left.minus(other);
-    expect(result.isEqual(left)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = minus(left.toArray(), right.toArray());
-    const expected = left.minus(right);
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/not_matching.test.ts

@@ -1,104 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { not_matching , isEqual } from 'src/operators';
-
-describe('.not_matching', () => {
-
-  const orders = Bmg([
-    { oid: 1, customer_id: 'C1', amount: 100 },
-    { oid: 2, customer_id: 'C2', amount: 200 },
-    { oid: 3, customer_id: 'C3', amount: 150 },
-  ]);
-
-  const customers = Bmg([
-    { customer_id: 'C1', name: 'Alice' },
-    { customer_id: 'C2', name: 'Bob' },
-  ]);
-
-  it('returns tuples from left that do NOT match right', () => {
-    const result = orders.not_matching(customers);
-    const expected = Bmg([
-      { oid: 3, customer_id: 'C3', amount: 150 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('returns all when no matches', () => {
-    const empty = Bmg([{ customer_id: 'C99' }]);
-    const result = orders.not_matching(empty);
-    expect(result.isEqual(orders)).to.be.true;
-  })
-
-  it('returns empty when all match', () => {
-    const all = Bmg([
-      { customer_id: 'C1' },
-      { customer_id: 'C2' },
-      { customer_id: 'C3' },
-    ]);
-    const result = orders.not_matching(all);
-    expect(result.isEqual(Bmg([]))).to.be.true;
-  })
-
-  it('supports explicit keys as [common_attr]', () => {
-    const result = orders.not_matching(customers, ['customer_id']);
-    const expected = Bmg([
-      { oid: 3, customer_id: 'C3', amount: 150 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports multiple keys as [attr1, attr2]', () => {
-    const inventory = Bmg([
-      { warehouse: 'W1', city: 'London', stock: 100 },
-      { warehouse: 'W2', city: 'London', stock: 200 },
-      { warehouse: 'W1', city: 'Paris', stock: 150 },
-    ]);
-    const shipments = Bmg([
-      { warehouse: 'W1', city: 'London' },
-    ]);
-    const result = inventory.not_matching(shipments, ['warehouse', 'city']);
-    const expected = Bmg([
-      { warehouse: 'W2', city: 'London', stock: 200 },
-      { warehouse: 'W1', city: 'Paris', stock: 150 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports explicit keys as { left: right }', () => {
-    const suppliers = Bmg([
-      { sid: 'S1', city: 'London' },
-      { sid: 'S2', city: 'Paris' },
-      { sid: 'S3', city: 'Athens' },
-    ]);
-    const cities = Bmg([{ location: 'London' }, { location: 'Paris' }]);
-    const result = suppliers.not_matching(cities, { city: 'location' });
-    const expected = Bmg([{ sid: 'S3', city: 'Athens' }]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports multiple keys as { left1: right1, left2: right2 }', () => {
-    const people = Bmg([
-      { id: 1, first: 'John', last: 'Doe' },
-      { id: 2, first: 'Jane', last: 'Smith' },
-      { id: 3, first: 'John', last: 'Smith' },
-    ]);
-    const records = Bmg([
-      { fname: 'John', lname: 'Doe' },
-      { fname: 'Jane', lname: 'Smith' },
-    ]);
-    const result = people.not_matching(records, { first: 'fname', last: 'lname' });
-    const expected = Bmg([
-      { id: 3, first: 'John', last: 'Smith' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = not_matching(orders.toArray(), customers.toArray());
-    const expected = orders.not_matching(customers);
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/one.test.ts

@@ -1,19 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { SUPPLIERS } from 'tests/fixtures';
-import { one } from 'src/operators';
-
-describe('.one', () => {
-
-  it('is available on relations', () => {
-    expect(typeof SUPPLIERS.one).to.eql('function')
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const tuple = { sid: 'S1' }
-    const tuples = [tuple]
-    expect(one(tuples)).to.eql(tuple)
-  })
-
-});

package/tests/operators/prefix.test.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { SUPPLIERS } from 'tests/fixtures';
-import { prefix , isEqual } from 'src/operators';
-
-describe('.prefix', () => {
-
-  it('prefixes all attribute names', () => {
-    const prefixed = SUPPLIERS.prefix('supplier_');
-    const expected = Bmg([
-      {supplier_sid: 'S1', supplier_name: 'Smith', supplier_status: 20, supplier_city: 'London' },
-      {supplier_sid: 'S2', supplier_name: 'Jones', supplier_status: 10, supplier_city: 'Paris' },
-      {supplier_sid: 'S3', supplier_name: 'Blake', supplier_status: 30, supplier_city: 'Paris' },
-      {supplier_sid: 'S4', supplier_name: 'Clark', supplier_status: 20, supplier_city: 'London' },
-      {supplier_sid: 'S5', supplier_name: 'Adams', supplier_status: 30, supplier_city: 'Athens' },
-    ]);
-    expect(prefixed.isEqual(expected)).to.be.true;
-  })
-
-  it('can exclude specific attributes', () => {
-    const prefixed = SUPPLIERS.prefix('s_', { except: ['sid'] });
-    const smith = prefixed.restrict({sid: 'S1'}).one();
-    expect(smith).to.have.property('sid', 'S1');
-    expect(smith).to.have.property('s_name', 'Smith');
-    expect(smith).to.have.property('s_city', 'London');
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const input = SUPPLIERS.toArray();
-    const res = prefix(input, 'x_');
-    const expected = SUPPLIERS.prefix('x_');
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/project.test.ts

@@ -1,48 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { SUPPLIERS } from 'tests/fixtures';
-import { project , isEqual } from 'src/operators';
-
-describe('.project', () => {
-
-  it('keeps only specified attributes', () => {
-    const result = SUPPLIERS.project(['name', 'city']);
-    const expected = Bmg([
-      { name: 'Smith', city: 'London' },
-      { name: 'Jones', city: 'Paris' },
-      { name: 'Blake', city: 'Paris' },
-      { name: 'Clark', city: 'London' },
-      { name: 'Adams', city: 'Athens' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('removes duplicates (set semantics)', () => {
-    // Projecting to 'city' only should yield 3 unique cities, not 5 tuples
-    const result = SUPPLIERS.project(['city']);
-    const expected = Bmg([
-      { city: 'London' },
-      { city: 'Paris' },
-      { city: 'Athens' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('ignores missing attributes', () => {
-    // @ts-expect-error - testing runtime behavior with invalid attribute
-    const result = SUPPLIERS.project(['name', 'nonexistent']);
-    const smith = result.restrict({ name: 'Smith' }).one();
-    expect(smith).to.have.property('name');
-    expect(smith).to.not.have.property('nonexistent');
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const input = SUPPLIERS.toArray();
-    const res = project(input, ['name', 'city']);
-    const expected = SUPPLIERS.project(['name', 'city']);
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/rename.test.ts

@@ -1,39 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { SUPPLIERS } from 'tests/fixtures';
-import { rename , isEqual } from 'src/operators';
-
-describe('.rename', () => {
-
-  const renaming = {sid: 'id', name: 'lastname'}
-
-  it('allows renaming relation tuples', () => {
-    const renamed = SUPPLIERS.rename(renaming);
-    const expected = Bmg([
-      {id: 'S1', lastname: 'Smith', status: 20, city: 'London' },
-      {id: 'S2', lastname: 'Jones', status: 10, city: 'Paris' },
-      {id: 'S3', lastname: 'Blake', status: 30, city: 'Paris' },
-      {id: 'S4', lastname: 'Clark', status: 20, city: 'London' },
-      {id: 'S5', lastname: 'Adams', status: 30, city: 'Athens' },
-    ]);
-    expect(renamed.isEqual(expected)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const input = SUPPLIERS.toArray();
-    const res = rename(input, renaming);
-    const expected = SUPPLIERS.rename(renaming);
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-  it('supports a pure function', () => {
-    const input = SUPPLIERS.toArray();
-    const renamed = rename(input, (attr) => attr.toUpperCase()) as any[];
-    const smith = Bmg(renamed).restrict({ SID: 'S1' }).one();
-    const keys = Object.keys(smith).sort();
-    expect(keys).to.eql(['CITY', 'NAME', 'SID', 'STATUS']);
-  })
-
-});

package/tests/operators/restrict.test.ts

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

package/tests/operators/suffix.test.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { SUPPLIERS } from 'tests/fixtures';
-import { suffix , isEqual } from 'src/operators';
-
-describe('.suffix', () => {
-
-  it('suffixes all attribute names', () => {
-    const suffixed = SUPPLIERS.suffix('_s');
-    const expected = Bmg([
-      {sid_s: 'S1', name_s: 'Smith', status_s: 20, city_s: 'London' },
-      {sid_s: 'S2', name_s: 'Jones', status_s: 10, city_s: 'Paris' },
-      {sid_s: 'S3', name_s: 'Blake', status_s: 30, city_s: 'Paris' },
-      {sid_s: 'S4', name_s: 'Clark', status_s: 20, city_s: 'London' },
-      {sid_s: 'S5', name_s: 'Adams', status_s: 30, city_s: 'Athens' },
-    ]);
-    expect(suffixed.isEqual(expected)).to.be.true;
-  })
-
-  it('can exclude specific attributes', () => {
-    const suffixed = SUPPLIERS.suffix('_x', { except: ['sid'] });
-    const smith = suffixed.restrict({sid: 'S1'}).one();
-    expect(smith).to.have.property('sid', 'S1');
-    expect(smith).to.have.property('name_x', 'Smith');
-    expect(smith).to.have.property('city_x', 'London');
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const input = SUPPLIERS.toArray();
-    const res = suffix(input, '_y');
-    const expected = SUPPLIERS.suffix('_y');
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/summarize.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { SUPPLIERS } from 'tests/fixtures';
-import { Bmg } from 'src';
-import { summarize, isEqual } from 'src/operators';
-
-describe('.summarize', () => {
-
-  it('counts tuples per group', () => {
-    const result = SUPPLIERS.summarize(['city'], { count: 'count' });
-    const expected = Bmg([
-      { city: 'London', count: 2 },
-      { city: 'Paris', count: 2 },
-      { city: 'Athens', count: 1 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('sums values per group', () => {
-    const result = SUPPLIERS.summarize(['city'], {
-      totalStatus: { op: 'sum', attr: 'status' }
-    });
-    const expected = Bmg([
-      { city: 'London', totalStatus: 40 },  // 20 + 20
-      { city: 'Paris', totalStatus: 40 },   // 10 + 30
-      { city: 'Athens', totalStatus: 30 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('computes min/max per group', () => {
-    const result = SUPPLIERS.summarize(['city'], {
-      minStatus: { op: 'min', attr: 'status' },
-      maxStatus: { op: 'max', attr: 'status' }
-    });
-    const expected = Bmg([
-      { city: 'London', minStatus: 20, maxStatus: 20 },
-      { city: 'Paris', minStatus: 10, maxStatus: 30 },
-      { city: 'Athens', minStatus: 30, maxStatus: 30 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('computes average per group', () => {
-    const result = SUPPLIERS.summarize(['city'], {
-      avgStatus: { op: 'avg', attr: 'status' }
-    });
-    const expected = Bmg([
-      { city: 'London', avgStatus: 20 },   // (20 + 20) / 2
-      { city: 'Paris', avgStatus: 20 },    // (10 + 30) / 2
-      { city: 'Athens', avgStatus: 30 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('collects values per group', () => {
-    const result = SUPPLIERS.summarize(['city'], {
-      names: { op: 'collect', attr: 'name' }
-    });
-    // collect returns arrays - check specific group
-    const paris = result.restrict({ city: 'Paris' }).one();
-    expect(paris.names).to.include('Jones');
-    expect(paris.names).to.include('Blake');
-  })
-
-  it('supports custom aggregator functions', () => {
-    const data = Bmg([
-      { city: 'NYC', name: 'Alice' },
-      { city: 'NYC', name: 'Bob' },
-    ]);
-    const result = data.summarize(['city'], {
-      names: (tuples) => tuples.map(t => t.name).sort().join(', ')
-    });
-    const expected = Bmg([
-      { city: 'NYC', names: 'Alice, Bob' }
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports multiple group-by attributes', () => {
-    const data = Bmg([
-      { a: 1, b: 'x', v: 10 },
-      { a: 1, b: 'x', v: 20 },
-      { a: 1, b: 'y', v: 30 },
-      { a: 2, b: 'x', v: 40 },
-    ]);
-    const result = data.summarize(['a', 'b'], { sum: { op: 'sum', attr: 'v' } });
-    const expected = Bmg([
-      { a: 1, b: 'x', sum: 30 },
-      { a: 1, b: 'y', sum: 30 },
-      { a: 2, b: 'x', sum: 40 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('handles empty by array (grand total)', () => {
-    const result = SUPPLIERS.summarize([], { total: 'count' });
-    const expected = Bmg([{ total: 5 }]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const standalone = summarize(SUPPLIERS.toArray(), ['city'], { count: 'count' });
-    const expected = SUPPLIERS.summarize(['city'], { count: 'count' });
-    expect(isEqual(standalone, expected)).to.be.true;
-  })
-
-});