@enspirit/bmg-js 1.0.0 → 1.0.2

package/tests/operators/cross_product.test.ts

@@ -1,90 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { cross_product, cross_join , isEqual } from 'src/operators';
-
-describe('.cross_product', () => {
-
-  const colors = Bmg([
-    { color: 'red' },
-    { color: 'blue' },
-  ]);
-
-  const sizes = Bmg([
-    { size: 'S' },
-    { size: 'M' },
-    { size: 'L' },
-  ]);
-
-  it('computes cartesian product of two relations', () => {
-    const result = colors.cross_product(sizes);
-    const expected = Bmg([
-      { color: 'red', size: 'S' },
-      { color: 'red', size: 'M' },
-      { color: 'red', size: 'L' },
-      { color: 'blue', size: 'S' },
-      { color: 'blue', size: 'M' },
-      { color: 'blue', size: 'L' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('cross_join is an alias for cross_product', () => {
-    const withCrossProduct = colors.cross_product(sizes);
-    const withCrossJoin = colors.cross_join(sizes);
-    expect(withCrossProduct.isEqual(withCrossJoin)).to.be.true;
-  })
-
-  it('handles DUM', () => {
-    const empty = Bmg([]);
-    const result = colors.cross_product(empty);
-    expect(result.toArray()).to.eql([]);
-  })
-
-  it('handles DEE', () => {
-    const empty = Bmg([{}]);
-    const result = colors.cross_product(empty);
-    expect(result.isEqual(colors)).to.be.true;
-  })
-
-  it('clashing right attributes are ignored', () => {
-    const left = Bmg([{ x: 1, y: 2 }]);
-    const right = Bmg([{ y: 100, z: 3 }]);
-    const result = left.cross_product(right);
-    const expected = Bmg([{ x: 1, y: 2, z: 3 }]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('clashing right attributes are ignored with multiple tuples', () => {
-    const left = Bmg([
-      { x: 1, y: 'a' },
-      { x: 2, y: 'b' },
-    ]);
-    const right = Bmg([
-      { y: 'ignored', z: 10 },
-      { y: 'also_ignored', z: 20 },
-    ]);
-    const result = left.cross_product(right);
-    const expected = Bmg([
-      { x: 1, y: 'a', z: 10 },
-      { x: 1, y: 'a', z: 20 },
-      { x: 2, y: 'b', z: 10 },
-      { x: 2, y: 'b', z: 20 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = cross_product(colors.toArray(), sizes.toArray());
-    const expected = colors.cross_product(sizes);
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-  it('cross_join standalone is also available', () => {
-    const res = cross_join(colors.toArray(), sizes.toArray());
-    const expected = colors.cross_join(sizes);
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/exclude.test.ts

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { SUPPLIERS } from 'tests/fixtures';
-import { exclude , isEqual } from 'src/operators';
-
-describe('.exclude', () => {
-
-  it('filters out tuples matching the predicate', () => {
-    const nonParis = SUPPLIERS.exclude({city: 'Paris'});
-    const expected = Bmg([
-      {sid: 'S1', name: 'Smith', status: 20, city: 'London' },
-      {sid: 'S4', name: 'Clark', status: 20, city: 'London' },
-      {sid: 'S5', name: 'Adams', status: 30, city: 'Athens' },
-    ]);
-    expect(nonParis.isEqual(expected)).to.be.true;
-  })
-
-  it('works with a function predicate', () => {
-    const lowStatus = SUPPLIERS.exclude((t) => (t.status as number) >= 20);
-    const expected = Bmg([
-      {sid: 'S2', name: 'Jones', status: 10, city: 'Paris' },
-    ]);
-    expect(lowStatus.isEqual(expected)).to.be.true;
-  })
-
-  it('is the inverse of restrict', () => {
-    const restricted = SUPPLIERS.restrict({city: 'Paris'});
-    const excluded = SUPPLIERS.exclude({city: 'Paris'});
-    // Union of restrict and exclude should give the original relation
-    const reunion = restricted.union(excluded);
-    expect(reunion.isEqual(SUPPLIERS)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const input = SUPPLIERS.toArray();
-    const res = exclude(input, { city: 'Paris' });
-    const expected = SUPPLIERS.exclude({ city: 'Paris' });
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/extend.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import { SUPPLIERS } from 'tests/fixtures';
-import { extend , isEqual } from 'src/operators';
-
-describe('.extend', () => {
-
-  it('adds computed attributes', () => {
-    const result = SUPPLIERS.extend({
-      statusLabel: (t) => `Status: ${t.status}`
-    });
-    const smith = result.restrict({ sid: 'S1' }).one();
-    expect(smith.statusLabel).to.eql('Status: 20');
-    expect(smith.name).to.eql('Smith');
-  })
-
-  it('copies attributes with string shortcut', () => {
-    const result = SUPPLIERS.extend({
-      location: 'city'
-    });
-    const smith = result.restrict({ sid: 'S1' }).one();
-    expect(smith.location).to.eql('London');
-    expect(smith.city).to.eql('London');
-  })
-
-  it('supports multiple extensions', () => {
-    const result = SUPPLIERS.extend({
-      location: 'city',
-      doubled: (t) => (t.status as number) * 2
-    });
-    const smith = result.restrict({ sid: 'S1' }).one();
-    expect(smith.location).to.eql('London');
-    expect(smith.doubled).to.eql(40);
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const input = SUPPLIERS.toArray();
-    const res = extend(input, { location: 'city' });
-    const expected = SUPPLIERS.extend({ location: 'city' });
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/group.test.ts

@@ -1,69 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { group , isEqual } from 'src/operators';
-
-describe('.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 },
-  ]);
-
-  it('groups specified attributes into nested relation', () => {
-    const result = orders.group(['item', 'qty'], 'items');
-    const expected = Bmg([
-      {
-        order_id: 1,
-        customer: 'Alice',
-        items: Bmg([
-          { item: 'Apple', qty: 2 },
-          { item: 'Banana', qty: 3 },
-        ])
-      },
-      {
-        order_id: 2,
-        customer: 'Bob',
-        items: Bmg([
-          { item: 'Cherry', qty: 1 },
-        ])
-      },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('preserves non-grouped attributes', () => {
-    const result = orders.group(['item', 'qty'], 'items');
-    const bob = result.restrict({ customer: 'Bob' }).one();
-    expect(bob).to.have.property('order_id', 2);
-    expect(bob).to.have.property('customer', 'Bob');
-    expect(bob).to.have.property('items');
-    expect(Object.keys(bob).sort()).to.eql(['customer', 'items', 'order_id']);
-  })
-
-  it('handles single-item groups', () => {
-    const result = orders.group(['item', 'qty'], 'items');
-    const bobOnly = result.restrict({ customer: 'Bob' });
-    const expected = Bmg([{
-      order_id: 2,
-      customer: 'Bob',
-      items: Bmg([{ item: 'Cherry', qty: 1 }])
-    }]);
-    expect(bobOnly.isEqual(expected)).to.be.true;
-  })
-
-  it('handles empty relation', () => {
-    const empty = Bmg([]);
-    const result = empty.group(['x'], 'grouped');
-    expect(result.isEqual(Bmg([]))).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = group(orders.toArray(), ['item', 'qty'], 'items');
-    const expected = orders.group(['item', 'qty'], 'items');
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/image.test.ts

@@ -1,152 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { image , isEqual } from 'src/operators';
-
-describe('.image', () => {
-
-  const suppliers = Bmg([
-    { sid: 'S1', name: 'Smith', city: 'London' },
-    { sid: 'S2', name: 'Jones', city: 'Paris' },
-    { sid: 'S3', name: 'Blake', city: 'Paris' },
-  ]);
-
-  const shipments = Bmg([
-    { sid: 'S1', pid: 'P1', qty: 100 },
-    { sid: 'S1', pid: 'P2', qty: 200 },
-    { sid: 'S2', pid: 'P1', qty: 300 },
-  ]);
-
-  it('adds relation-valued attribute with matching tuples', () => {
-    const result = suppliers.image(shipments, 'shipments');
-    const expected = Bmg([
-      {
-        sid: 'S1', name: 'Smith', city: 'London',
-        shipments: Bmg([
-          { pid: 'P1', qty: 100 },
-          { pid: 'P2', qty: 200 },
-        ])
-      },
-      {
-        sid: 'S2', name: 'Jones', city: 'Paris',
-        shipments: Bmg([
-          { pid: 'P1', qty: 300 },
-        ])
-      },
-      {
-        sid: 'S3', name: 'Blake', city: 'Paris',
-        shipments: Bmg([])
-      },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports explicit keys as { left: right }', () => {
-    const cities = Bmg([
-      { location: 'London', country: 'UK' },
-      { location: 'Paris', country: 'France' },
-    ]);
-    const result = suppliers.image(cities, 'city_info', { city: 'location' });
-    const expected = Bmg([
-      { sid: 'S1', name: 'Smith', city: 'London', city_info: Bmg([{ country: 'UK' }]) },
-      { sid: 'S2', name: 'Jones', city: 'Paris', city_info: Bmg([{ country: 'France' }]) },
-      { sid: 'S3', name: 'Blake', city: 'Paris', city_info: Bmg([{ country: 'France' }]) },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports explicit keys as [common_attr]', () => {
-    const result = suppliers.image(shipments, 'shipments', ['sid']);
-    const expected = Bmg([
-      {
-        sid: 'S1', name: 'Smith', city: 'London',
-        shipments: Bmg([
-          { pid: 'P1', qty: 100 },
-          { pid: 'P2', qty: 200 },
-        ])
-      },
-      {
-        sid: 'S2', name: 'Jones', city: 'Paris',
-        shipments: Bmg([
-          { pid: 'P1', qty: 300 },
-        ])
-      },
-      {
-        sid: 'S3', name: 'Blake', city: 'Paris',
-        shipments: Bmg([])
-      },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports multiple attributes as join key', () => {
-    const inventory = Bmg([
-      { warehouse: 'W1', city: 'London', stock: 100 },
-      { warehouse: 'W2', city: 'London', stock: 200 },
-      { warehouse: 'W3', city: 'Paris', stock: 150 },
-    ]);
-    const orders = Bmg([
-      { warehouse: 'W1', city: 'London', item: 'A', qty: 10 },
-      { warehouse: 'W1', city: 'London', item: 'B', qty: 20 },
-      { warehouse: 'W3', city: 'Paris', item: 'C', qty: 30 },
-    ]);
-    const result = inventory.image(orders, 'orders', ['warehouse', 'city']);
-    const expected = Bmg([
-      {
-        warehouse: 'W1', city: 'London', stock: 100,
-        orders: Bmg([
-          { item: 'A', qty: 10 },
-          { item: 'B', qty: 20 },
-        ])
-      },
-      {
-        warehouse: 'W2', city: 'London', stock: 200,
-        orders: Bmg([])
-      },
-      {
-        warehouse: 'W3', city: 'Paris', stock: 150,
-        orders: Bmg([
-          { item: 'C', qty: 30 },
-        ])
-      },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('supports multiple attributes as { left: right } object', () => {
-    const people = Bmg([
-      { id: 1, first: 'John', last: 'Doe' },
-      { id: 2, first: 'Jane', last: 'Smith' },
-    ]);
-    const records = Bmg([
-      { fname: 'John', lname: 'Doe', year: 2020, score: 85 },
-      { fname: 'John', lname: 'Doe', year: 2021, score: 90 },
-      { fname: 'Jane', lname: 'Smith', year: 2020, score: 95 },
-    ]);
-    const result = people.image(records, 'scores', { first: 'fname', last: 'lname' });
-    const expected = Bmg([
-      {
-        id: 1, first: 'John', last: 'Doe',
-        scores: Bmg([
-          { year: 2020, score: 85 },
-          { year: 2021, score: 90 },
-        ])
-      },
-      {
-        id: 2, first: 'Jane', last: 'Smith',
-        scores: Bmg([
-          { year: 2020, score: 95 },
-        ])
-      },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = image(suppliers.toArray(), shipments.toArray(), 'shipments');
-    const expected = suppliers.image(shipments, 'shipments');
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/intersect.test.ts

@@ -1,53 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { intersect , isEqual } from 'src/operators';
-
-describe('.intersect', () => {
-
-  const left = Bmg([
-    { id: 1, name: 'Alice' },
-    { id: 2, name: 'Bob' },
-    { id: 3, name: 'Charlie' },
-  ]);
-
-  const right = Bmg([
-    { id: 2, name: 'Bob' },
-    { id: 3, name: 'Charlie' },
-    { id: 4, name: 'Diana' },
-  ]);
-
-  it('returns tuples present in both relations', () => {
-    const result = left.intersect(right);
-    const expected = Bmg([
-      { id: 2, name: 'Bob' },
-      { id: 3, name: 'Charlie' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('returns empty when no overlap', () => {
-    const other = Bmg([{ id: 99, name: 'Nobody' }]);
-    const result = left.intersect(other);
-    expect(result.isEqual(Bmg([]))).to.be.true;
-  })
-
-  it('returns all when identical', () => {
-    const result = left.intersect(left);
-    expect(result.isEqual(left)).to.be.true;
-  })
-
-  it('is commutative (set semantics)', () => {
-    const lr = left.intersect(right);
-    const rl = right.intersect(left);
-    expect(lr.isEqual(rl)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = intersect(left.toArray(), right.toArray());
-    const expected = left.intersect(right);
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});

package/tests/operators/isEqual.test.ts

@@ -1,111 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { isEqual } from 'src/operators';
-
-describe('.isEqual', () => {
-
-  it('returns true for identical relations', () => {
-    const r = Bmg([
-      { id: 1, name: 'Alice' },
-      { id: 2, name: 'Bob' },
-    ]);
-    expect(r.isEqual(r)).to.be.true;
-  })
-
-  it('returns true for relations with same tuples', () => {
-    const r1 = Bmg([
-      { id: 1, name: 'Alice' },
-      { id: 2, name: 'Bob' },
-    ]);
-    const r2 = Bmg([
-      { id: 1, name: 'Alice' },
-      { id: 2, name: 'Bob' },
-    ]);
-    expect(r1.isEqual(r2)).to.be.true;
-  })
-
-  it('returns true regardless of tuple order', () => {
-    const r1 = Bmg([
-      { id: 1, name: 'Alice' },
-      { id: 2, name: 'Bob' },
-    ]);
-    const r2 = Bmg([
-      { id: 2, name: 'Bob' },
-      { id: 1, name: 'Alice' },
-    ]);
-    expect(r1.isEqual(r2)).to.be.true;
-  })
-
-  it('returns true regardless of attribute order', () => {
-    const r1 = Bmg([
-      { id: 1, name: 'Alice' },
-    ]);
-    const r2 = Bmg([
-      { name: 'Alice', id: 1 },
-    ]);
-    expect(r1.isEqual(r2)).to.be.true;
-  })
-
-  it('ignores duplicates (set semantics)', () => {
-    const r1 = Bmg([
-      { id: 1, name: 'Alice' },
-      { id: 1, name: 'Alice' },
-    ]);
-    const r2 = Bmg([
-      { id: 1, name: 'Alice' },
-    ]);
-    expect(r1.isEqual(r2)).to.be.true;
-  })
-
-  it('returns false for different tuple count', () => {
-    const r1 = Bmg([
-      { id: 1, name: 'Alice' },
-      { id: 2, name: 'Bob' },
-    ]);
-    const r2 = Bmg([
-      { id: 1, name: 'Alice' },
-    ]);
-    expect(r1.isEqual(r2)).to.be.false;
-  })
-
-  it('returns false for different tuple values', () => {
-    const r1 = Bmg([
-      { id: 1, name: 'Alice' },
-    ]);
-    const r2 = Bmg([
-      { id: 1, name: 'Bob' },
-    ]);
-    expect(r1.isEqual(r2)).to.be.false;
-  })
-
-  it('returns false for different attributes', () => {
-    const r1 = Bmg([
-      { id: 1, name: 'Alice' },
-    ]);
-    const r2 = Bmg([
-      { id: 1, city: 'Paris' },
-    ]);
-    expect(r1.isEqual(r2)).to.be.false;
-  })
-
-  it('returns true for empty relations', () => {
-    const r1 = Bmg([]);
-    const r2 = Bmg([]);
-    expect(r1.isEqual(r2)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const left = [{ id: 1, name: 'Alice' }];
-    const right = [{ name: 'Alice', id: 1 }];
-    expect(isEqual(left, right)).to.be.true;
-  })
-
-  it('works with array operand', () => {
-    const r = Bmg([{ id: 1, name: 'Alice' }]);
-    const arr = [{ id: 1, name: 'Alice' }];
-    expect(r.isEqual(arr)).to.be.true;
-  })
-
-});

package/tests/operators/join.test.ts

@@ -1,116 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bmg } from 'src';
-import { join , isEqual } from 'src/operators';
-
-describe('.join', () => {
-
-  const suppliers = Bmg([
-    { sid: 'S1', name: 'Smith', city: 'London' },
-    { sid: 'S2', name: 'Jones', city: 'Paris' },
-    { sid: 'S3', name: 'Blake', city: 'Paris' },
-  ]);
-
-  const parts = Bmg([
-    { pid: 'P1', pname: 'Nut', city: 'London' },
-    { pid: 'P2', pname: 'Bolt', city: 'Paris' },
-    { pid: 'P3', pname: 'Screw', city: 'Athens' },
-  ]);
-
-  it('performs natural join on common attributes', () => {
-    const result = suppliers.join(parts);
-    const expected = Bmg([
-      { sid: 'S1', name: 'Smith', city: 'London', pid: 'P1', pname: 'Nut' },
-      { sid: 'S2', name: 'Jones', city: 'Paris', pid: 'P2', pname: 'Bolt' },
-      { sid: 'S3', name: 'Blake', city: 'Paris', pid: 'P2', pname: 'Bolt' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('joins on specified attributes as [common_attr]', () => {
-    const result = suppliers.join(parts, ['city']);
-    const expected = Bmg([
-      { sid: 'S1', name: 'Smith', city: 'London', pid: 'P1', pname: 'Nut' },
-      { sid: 'S2', name: 'Jones', city: 'Paris', pid: 'P2', pname: 'Bolt' },
-      { sid: 'S3', name: 'Blake', city: 'Paris', pid: 'P2', pname: 'Bolt' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('joins on multiple attributes 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', qty: 10 },
-      { warehouse: 'W1', city: 'Paris', qty: 20 },
-    ]);
-    const result = inventory.join(shipments, ['warehouse', 'city']);
-    const expected = Bmg([
-      { warehouse: 'W1', city: 'London', stock: 100, qty: 10 },
-      { warehouse: 'W1', city: 'Paris', stock: 150, qty: 20 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('joins on different attribute names as { left: right }', () => {
-    const locations = Bmg([
-      { location: 'London', country: 'UK' },
-      { location: 'Paris', country: 'France' },
-    ]);
-    const result = suppliers.join(locations, { city: 'location' });
-    const expected = Bmg([
-      { sid: 'S1', name: 'Smith', city: 'London', country: 'UK' },
-      { sid: 'S2', name: 'Jones', city: 'Paris', country: 'France' },
-      { sid: 'S3', name: 'Blake', city: 'Paris', country: 'France' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('joins on multiple different attribute names 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.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 },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  it('returns empty for no matches', () => {
-    const other = Bmg([{ city: 'Tokyo' }]);
-    const result = suppliers.join(other);
-    expect(result.isEqual(Bmg([]))).to.be.true;
-  })
-
-  it('handles cartesian product when no common attrs', () => {
-    const colors = Bmg([{ color: 'red' }, { color: 'blue' }]);
-    const sizes = Bmg([{ size: 'S' }, { size: 'M' }]);
-    const result = colors.join(sizes);
-    const expected = Bmg([
-      { color: 'red', size: 'S' },
-      { color: 'red', size: 'M' },
-      { color: 'blue', size: 'S' },
-      { color: 'blue', size: 'M' },
-    ]);
-    expect(result.isEqual(expected)).to.be.true;
-  })
-
-  ///
-
-  it('can be used standalone', () => {
-    const res = join(suppliers.toArray(), parts.toArray(), ['city']);
-    const expected = suppliers.join(parts, ['city']);
-    expect(isEqual(res, expected)).to.be.true;
-  })
-
-});