sorla-db 1.1.0 → 1.3.0

package/test/feature_collection_queries.test.js

@@ -1,224 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const faker = require('faker')
-const sorla = require('../src/sorla.js')
-const helper = require('../src/helper.js')
-
-describe('SORLA Collection Queries Feature Test', () => {
-    beforeAll(() => {
-        this.srla = new sorla();
-        this.dbname = faker.random.word();
-        this.srla.createDb(this.dbname);
-        this.srla.useDb(this.dbname);
-        this.collectionName = faker.random.word();
-        this.srla.db.createCollection(this.collectionName);
-        this.objects = helper.createFakeCollection(this.srla, this.collectionName, 30);
-    });
-
-    it('Test if the first document in the collection is the same first document on the objects array', () => {
-        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
-        const firstObj = this.objects[0];
-        expect(firstDoc).to.deep.equal(firstObj);
-    });
-
-    it('Takes the data field name from the document inside the collection', () => {
-        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
-        const firstObj = this.objects[0];
-        expect(firstDoc.name).to.be.a('string').equal(firstObj.name);
-    });
-
-    it('Takes the data field email from the document inside the collection', () => {
-        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
-        const firstObj = this.objects[0];
-        expect(firstDoc.email).to.be.a('string').equal(firstObj.email);
-    });
-
-    it('Takes the data field age from the document inside the collection', () => {
-        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
-        const firstObj = this.objects[0];
-        expect(firstDoc.age).to.be.a('number').equal(firstObj.age);
-    });
-
-    it('Creates a few documents and search for one of them', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const doc = this.srla.db[this.collectionName].findOne({ uuid: item1.uuid }, { _id: 0 });
-        expect(doc).to.deep.equal(item1);
-    });
-
-    it('Creates a few documents and search for some of them', () => {
-        const [item1, item2] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            $or: [
-                { uuid: item1.uuid },
-                { uuid: item2.uuid }
-            ]
-        });
-
-        expect(docs.length).to.be.equal(2);
-    });
-
-    it('Creates a few documents and search using not', () => {
-        const [item1] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find(
-            {
-                uuid: { 
-                    $not: {
-                        $eq: item1.uuid 
-                    }
-                }
-            }
-        );
-
-        expect(docs.length).to.be.equal(this.objects.length - 1);
-    });
-
-    it('Creates a few documents and search using not with more than one expression', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find(
-            {
-                age: { 
-                    $not: {
-                        $eq: item1.age,
-                        $gt: 18
-                    }
-                }
-            }
-        );
-
-        // $not negates the whole condition: excluded when age equals item1.age AND is over 18
-        const expected = this.objects.filter(obj => !(obj.age === item1.age && obj.age > 18));
-        expect(docs.length).to.be.equal(expected.length);
-    });
-
-    it('Creates a few documents and search it using nor', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].findOne({
-            $nor: [
-                {name: item1.name},
-                {age: item1.age}
-            ]
-        });
-
-        expect(docs.name).to.not.be.equal(item1.name);
-        expect(docs.age).to.not.be.equal(item1.age);
-    });
-
-    it('Creates a few documents and search it using nor with more than one expression', () => {
-        const [item1, item2] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            $nor: [
-                {name: item1.name},
-                {age: item1.age},
-                {name: item2.name},
-                {age: item2.age}
-            ]
-        });
-
-        // random names and ages can repeat, so count the expected documents instead of assuming 2
-        const expected = this.objects.filter(obj => obj.name !== item1.name && obj.age !== item1.age && obj.name !== item2.name && obj.age !== item2.age);
-        expect(docs.length).to.be.equal(expected.length);
-    });
-
-    // sorting is covered by test/feature_cursor.test.js
-
-    it('Test equal comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const doc = this.srla.db[this.collectionName].findOne({ uuid: item1.uuid }, { _id: 0 });
-        expect(doc).to.deep.equal(item1);
-    });
-
-    it('Test not equal comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            uuid: { $ne: item1.uuid }
-        });
-
-        expect(docs.length).to.be.equal(this.objects.length - 1);
-    });
-
-    it('Test greater than comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $gt: item1.age }
-        });
-
-        countAges = this.objects.filter(obj => obj.age > item1.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test greater than or equal comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $gte: item1.age }
-        });
-
-        countAges = this.objects.filter(obj => obj.age >= item1.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test less than comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $lt: item1.age }
-        });
-
-        countAges = this.objects.filter(obj => obj.age < item1.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test less than or equal comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $lte: item1.age }
-        });
-
-        countAges = this.objects.filter(obj => obj.age <= item1.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test in comparison', () => {
-        const [item1, item2] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $in: [item1.age, item2.age] }
-        });
-
-        countAges = this.objects.filter(obj => obj.age === item1.age || obj.age === item2.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test not in comparison', () => {
-        const [item1, item2] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $nin: [item1.age, item2.age] }
-        });
-
-        countAges = this.objects.filter(obj => obj.age !== item1.age && obj.age !== item2.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test mixed comparison with and', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            $and: [
-                { name: item1.name },
-                { age: item1.age }
-            ]
-        });
-
-        const filtered = this.objects.filter(obj => obj.name === item1.name && obj.age === item1.age);
-        expect(docs.length).to.be.equal(filtered.length);
-    });
-
-    it('Test mixed comparison with or', () => {
-        const [item1, item2] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            $or: [
-                { name: item1.name },
-                { age: item2.age }
-            ]
-        });
-
-        const filtered = this.objects.filter(obj => obj.name === item1.name || obj.age === item2.age);
-        expect(docs.length).to.be.equal(filtered.length);
-    });
-});

package/test/feature_cursor.test.js

@@ -1,84 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const sorla = require('../src/sorla.js')
-
-describe('SORLA cursor', () => {
-    let people;
-
-    beforeAll(() => {
-        const srla = new sorla();
-        srla.useDb('cursor');
-        srla.db.createCollection('people');
-        people = srla.db.people;
-        for(const [name, age] of [['Carla', 42], ['Ana', 25], ['Bruno', 31]])
-            people.insertOne({ name, age, email: `${name.toLowerCase()}@mail.com` });
-        // projection logs every removed property
-        jest.spyOn(console, 'log').mockImplementation(() => {});
-    });
-
-    afterAll(() => jest.restoreAllMocks());
-
-    it('iterates with hasNext/next and can be reset', () => {
-        const cursor = people.find({});
-        expect(cursor.length).to.equal(3);
-        const names = [];
-        while(cursor.hasNext()) names.push(cursor.next()._data.name);
-        expect(names).to.deep.equal(['Carla', 'Ana', 'Bruno']);
-        expect(() => cursor.next()).to.throw('No more item to the cursor');
-        cursor.reset();
-        expect(cursor.next()._data.name).to.equal('Carla');
-    });
-
-    it('first() returns the data of the first document', () => {
-        expect(people.find({ age: { $gt: 30 } }).first().name).to.equal('Carla');
-    });
-
-    it('returns copies: changing a result does not change the collection', () => {
-        const cursor = people.find({ name: 'Ana' });
-        cursor.next()._data.age = 99;
-        expect(people.findOne({ name: 'Ana' }).age).to.equal(25);
-    });
-
-    it('projection with 0 removes fields from the results only', () => {
-        const cursor = people.find({ name: 'Ana' }, { email: 0 });
-        expect(cursor.next()._data).to.not.have.property('email');
-        expect(people.findOne({ name: 'Ana' }).email).to.equal('ana@mail.com');
-    });
-
-    it('last() gives access to the fields of the last document', () => {
-        expect(people.find({}).last().name).to.equal('Bruno');
-    });
-
-    it('push only accepts objects', () => {
-        const cursor = people.find({});
-        expect(() => cursor.push('x')).to.throw('The element must be an object');
-        cursor.push({ name: 'Extra' });
-        expect(cursor.length).to.equal(4);
-    });
-
-    // ---- known bugs: these document current behavior and will start failing once fixed
-
-    it.failing('sorts by a number ascending (cursor.js/document.js circular require)', () => {
-        const cursor = people.find({});
-        cursor.sort({ age: 1 });
-        expect(cursor.first().name).to.equal('Ana');
-    });
-
-    it.failing('sorts by several fields descending', () => {
-        const cursor = people.find({});
-        cursor.sort({ age: -1, name: 1 });
-        expect(cursor.first().name).to.equal('Carla');
-    });
-
-    it.failing('toArray returns plain objects (structuredClone of a Proxy)', () => {
-        expect(people.find({}).toArray().map(doc => doc.name)).to.deep.equal(['Carla', 'Ana', 'Bruno']);
-    });
-
-    it.failing('findOne returns null when nothing matches', () => {
-        expect(people.findOne({ name: 'Nobody' })).to.equal(null);
-    });
-
-
-    it.todo('projection with 1 keeps only the listed fields');
-    it.todo('skip() and limit()');
-});

package/test/feature_database.test.js

@@ -1,62 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const sorla = require('../src/sorla.js')
-
-describe('SORLA databases and collections', () => {
-    it('useDb creates the database when needed and selects it', () => {
-        const srla = new sorla();
-        expect(srla.dbExists('shop')).to.equal(false);
-        srla.useDb('shop');
-        expect(srla.dbExists('shop')).to.equal(true);
-        expect(srla.db.name).to.equal('shop');
-        expect(srla.countDb()).to.equal(1);
-    });
-
-    it('createDb returns the position, or false when the name exists', () => {
-        const srla = new sorla();
-        expect(srla.createDb('a')).to.equal(0);
-        expect(srla.createDb('b')).to.equal(1);
-        expect(srla.createDb('a')).to.equal(false);
-    });
-
-    it('keeps databases and their collections isolated', () => {
-        const srla = new sorla();
-        srla.useDb('one');
-        srla.db.createCollection('items');
-        srla.db.items.insertOne({ n: 1 });
-        srla.useDb('two');
-        srla.db.createCollection('items');
-        expect(srla.db.items.count()).to.equal(0);
-        srla.useDb('one');
-        expect(srla.db.items.count()).to.equal(1);
-    });
-
-    it('instances do not share data', () => {
-        const a = new sorla();
-        const b = new sorla();
-        a.useDb('x');
-        expect(b.dbExists('x')).to.equal(false);
-    });
-
-    it('rejects duplicated collection names', () => {
-        const srla = new sorla();
-        srla.useDb('dupes');
-        srla.db.createCollection('items');
-        expect(() => srla.db.createCollection('items')).to.throw('Collection already exists');
-        expect(srla.db.countCollections()).to.equal(1);
-    });
-
-    it('collection count, first, last and all', () => {
-        const srla = new sorla();
-        srla.useDb('basics');
-        srla.db.createCollection('items');
-        const items = srla.db.items;
-        expect(items.count()).to.equal(0);
-        items.insertOne({ n: 1 });
-        items.insertOne({ n: 2 });
-        expect(items.count()).to.equal(2);
-        expect(items.first.n).to.equal(1);
-        expect(items.last.n).to.equal(2);
-        expect(items.all.length).to.equal(2);
-    });
-});

package/test/feature_insert.test.js

@@ -1,116 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const sorla = require('../src/sorla.js')
-
-const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-
-describe('SORLA inserting documents', () => {
-    let srla;
-    let counter = 0;
-    const fresh = () => {
-        const name = `insert${++counter}`;
-        srla.db.createCollection(name);
-        return srla.db[name];
-    };
-
-    beforeAll(() => {
-        srla = new sorla();
-        srla.useDb('inserts');
-        // insertMany logs the count of invalid documents on every call
-        jest.spyOn(console, 'info').mockImplementation(() => {});
-    });
-
-    afterAll(() => jest.restoreAllMocks());
-
-    it('generates a uuid v4 _id when the document has none', () => {
-        const collection = fresh();
-        collection.insertOne({ name: 'Ana' });
-        expect(collection.first._id).to.match(UUID_V4);
-    });
-
-    it('generates unique ids', () => {
-        const collection = fresh();
-        for(let i = 0; i < 500; i++) collection.insertOne({ i });
-        const ids = new Set(collection.all.map(doc => doc._id));
-        expect(ids.size).to.equal(500);
-    });
-
-    it('keeps a provided _id', () => {
-        const collection = fresh();
-        collection.insertOne({ _id: 'custom-1', name: 'Ana' });
-        expect(collection.findOne({ _id: 'custom-1' }).name).to.equal('Ana');
-    });
-
-    it('keeps values of every type', () => {
-        const collection = fresh();
-        collection.insertOne({ text: 'a', number: 1.5, flag: false, list: [1, 'b'], nested: { deep: { value: 3 } }, empty: '' });
-        const doc = collection.first;
-        expect(doc).to.include({ text: 'a', number: 1.5, flag: false, empty: '' });
-        expect(doc.list).to.deep.equal([1, 'b']);
-        expect(doc.nested.deep.value).to.equal(3);
-    });
-
-    it('insertMany inserts in order and counts', () => {
-        const collection = fresh();
-        collection.insertMany([{ n: 1 }, { n: 2 }, { n: 3 }]);
-        expect(collection.count()).to.equal(3);
-        expect(collection.all.map(doc => doc.n)).to.deep.equal([1, 2, 3]);
-        expect(collection.last.n).to.equal(3);
-    });
-
-    it('calls the callbacks', () => {
-        const collection = fresh();
-        let calls = 0;
-        collection.insertOne({ n: 1 }, () => calls++);
-        collection.insertMany([{ n: 2 }], () => calls++);
-        expect(calls).to.equal(2);
-    });
-
-    it('rejects documents that are not objects', () => {
-        const collection = fresh();
-        expect(() => collection.insertOne('text')).to.throw('Invalid document type');
-        expect(() => collection.insertOne(['a'])).to.throw('Invalid document type');
-        expect(() => collection.insertMany('text')).to.throw();
-        expect(() => collection.insertMany([{ a: 1 }, 'b'])).to.throw('Documents must be an array of objects');
-    });
-
-    it('rejects keys with $ or .', () => {
-        const collection = fresh();
-        expect(() => collection.insertOne({ $name: 'a' })).to.throw('Invalid document keys');
-        expect(() => collection.insertOne({ 'a.b': 1 })).to.throw('Invalid document keys');
-        expect(() => collection.insertOne({ nested: { 'a.b': 1 } })).to.throw('Invalid document keys');
-        expect(() => collection.insertOne({ list: [{ 'a.b': 1 }] })).to.throw('Invalid document keys');
-        expect(collection.count()).to.equal(0);
-    });
-
-    // ---- known bugs: these document current behavior and will start failing once fixed
-
-    it.failing('accepts null values (Object.keys(null) in _validateKeys)', () => {
-        const collection = fresh();
-        collection.insertOne({ name: 'Ana', nickname: null });
-        expect(collection.first.nickname).to.equal(null);
-    });
-
-    it.failing('validates every nested object, not only the first one', () => {
-        const collection = fresh();
-        expect(() => collection.insertOne({ first: { ok: 1 }, second: { 'a.b': 1 } })).to.throw('Invalid document keys');
-    });
-
-    it.failing('rejects a duplicated _id', () => {
-        const collection = fresh();
-        collection.insertOne({ _id: 'same' });
-        expect(() => collection.insertOne({ _id: 'same' })).to.throw();
-    });
-
-    it.failing('insertMany explains why a non array is rejected (it calls reduce before validating)', () => {
-        const collection = fresh();
-        expect(() => collection.insertMany('text')).to.throw('Documents must be an array of objects');
-    });
-
-    it.failing('does not mutate the inserted object', () => {
-        const collection = fresh();
-        const input = { name: 'Ana' };
-        collection.insertOne(input);
-        expect(input).to.not.have.property('_id');
-    });
-});

package/test/feature_nested_queries.test.js

@@ -1,94 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const sorla = require('../src/sorla.js')
-
-describe('SORLA nested logical queries', () => {
-    let people;
-
-    beforeAll(() => {
-        const srla = new sorla();
-        srla.useDb('nestedQueries');
-        srla.db.createCollection('people');
-        srla.db.people.insertOne({ name: 'Ana', age: 25, city: 'A', tags: ['admin'] });
-        srla.db.people.insertOne({ name: 'Bruno', age: 31, city: 'B', tags: [] });
-        srla.db.people.insertOne({ name: 'Carla', age: 42, city: 'C', tags: ['admin', 'dev'] });
-        srla.db.people.insertOne({ name: 'Davi', age: 35, city: 'A' });
-        srla.db.people.insertOne({ name: 'Eva', age: 19, city: 'D', tags: ['dev'] });
-        people = srla.db.people;
-    });
-
-    const names = cursor => {
-        const result = [];
-        while(cursor.hasNext()) result.push(cursor.next()._data.name);
-        return result;
-    };
-
-    it('combines $and with a nested $or', () => {
-        const docs = people.find({
-            $and: [
-                { age: { $gte: 30 } },
-                { $or: [{ name: 'Carla' }, { city: { $in: ['A', 'B'] } }] }
-            ]
-        });
-        expect(names(docs)).to.deep.equal(['Bruno', 'Carla', 'Davi']);
-    });
-
-    it('nests groups at any depth', () => {
-        const docs = people.find({
-            $or: [
-                { $and: [{ city: 'A' }, { $or: [{ age: { $lt: 30 } }, { name: 'Davi' }] }] },
-                { $and: [{ city: 'D' }, { age: { $lt: 20 } }] }
-            ]
-        });
-        expect(names(docs)).to.deep.equal(['Ana', 'Davi', 'Eva']);
-    });
-
-    it('evaluates every operator of a field inside $or', () => {
-        const docs = people.find({ $or: [{ age: { $gte: 30, $lte: 35 } }, { name: 'Eva' }] });
-        expect(names(docs)).to.deep.equal(['Bruno', 'Davi', 'Eva']);
-    });
-
-    it('evaluates every operator of a field at the top level', () => {
-        expect(names(people.find({ age: { $gt: 20, $lt: 40, $ne: 31 } }))).to.deep.equal(['Ana', 'Davi']);
-    });
-
-    it('supports $nor with nested groups', () => {
-        const docs = people.find({ $nor: [{ city: 'A' }, { $and: [{ age: { $gt: 40 } }, { city: 'C' }] }] });
-        expect(names(docs)).to.deep.equal(['Bruno', 'Eva']);
-    });
-
-    it('$not inverts the whole condition, with one or more operators', () => {
-        expect(names(people.find({ age: { $not: { $gte: 30 } } }))).to.deep.equal(['Ana', 'Eva']);
-        expect(names(people.find({ age: { $not: { $gte: 30, $lte: 35 } } }))).to.deep.equal(['Ana', 'Carla', 'Eva']);
-    });
-
-    it('$not can be combined with other operators and logical groups', () => {
-        const docs = people.find({ $and: [{ city: { $not: { $eq: 'A' } } }, { $or: [{ age: { $lt: 20 } }, { name: 'Bruno' }] }] });
-        expect(names(docs)).to.deep.equal(['Bruno', 'Eva']);
-    });
-
-    it('matches array fields with $in', () => {
-        expect(names(people.find({ $or: [{ tags: { $in: ['dev'] } }, { age: 31 }] }))).to.deep.equal(['Bruno', 'Carla', 'Eva']);
-    });
-
-    it('a field missing in the document matches $ne and $nin', () => {
-        expect(names(people.find({ tags: { $ne: 'x' }, city: 'A' }))).to.deep.equal(['Ana', 'Davi']);
-        expect(names(people.find({ name: { $nin: ['Ana', 'Bruno'] }, age: { $lt: 40 } }))).to.deep.equal(['Davi', 'Eva']);
-    });
-
-    it('accepts null values in conditions', () => {
-        expect(people.find({ name: null }).length).to.equal(0);
-        expect(people.find({ $or: [{ name: null }, { name: 'Ana' }] }).length).to.equal(1);
-    });
-
-    it('findOne works with nested queries', () => {
-        const doc = people.findOne({ $and: [{ $or: [{ city: 'C' }, { city: 'D' }] }, { age: { $gt: 40 } }] });
-        expect(doc.name).to.equal('Carla');
-    });
-
-    it('rejects invalid queries with a clear error', () => {
-        expect(() => people.find({ $or: { name: 'Ana' } })).to.throw('The $or operator must be an array');
-        expect(() => people.find({ age: { $between: [1, 2] } })).to.throw('Unknown operator $between');
-        expect(() => people.find({ $not: { age: 1 } })).to.throw('$not operator must be used inside a field condition');
-    });
-});