sorla-db 1.1.0 → 1.3.0

package/test/feature_query_equivalence.test.js

@@ -1,165 +0,0 @@
-/**
- * Compares find() against a straightforward reference implementation of the query semantics,
- * over hand written queries and hundreds of randomly generated nested ones (seeded, so a failure
- * always reproduces). This catches logic bugs, not just crashes.
- */
-const chai = require('chai')
-const expect = chai.expect
-const sorla = require('../src/sorla.js')
-
-// deterministic PRNG (mulberry32)
-function prng(seed) {
-    return () => {
-        seed |= 0; seed = seed + 0x6D2B79F5 | 0;
-        let t = Math.imul(seed ^ seed >>> 15, 1 | seed);
-        t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-        return ((t ^ t >>> 14) >>> 0) / 4294967296;
-    };
-}
-
-const NAMES = ['Ana', 'Bruno', 'Carla', 'Davi', 'Eva', 'Fábio'];
-const CITIES = ['A', 'B', 'C', 'D'];
-const TAGS = ['admin', 'dev', 'ops'];
-
-function buildDocuments(random, count) {
-    const pick = list => list[Math.floor(random() * list.length)];
-    return Array.from({ length: count }, (_, n) => {
-        const doc = { n, name: pick(NAMES), city: pick(CITIES), score: Math.round(random() * 1000) / 10, active: random() > 0.5 };
-        if(random() > 0.15) doc.age = 18 + Math.floor(random() * 50);          // sometimes missing
-        if(random() > 0.3) doc.tags = TAGS.filter(() => random() > 0.5);       // array, sometimes missing
-        // nickname is often missing; null values cannot be stored yet (see feature_insert.test.js)
-        if(random() > 0.5) doc.nickname = pick(NAMES);
-        return doc;
-    });
-}
-
-// ---- reference semantics, written independently of src/
-const compare = {
-    $eq: (v, q) => !Array.isArray(q) && v === q,
-    $ne: (v, q) => !Array.isArray(q) && v !== q,
-    $gt: (v, q) => !Array.isArray(q) && v > q,
-    $gte: (v, q) => !Array.isArray(q) && v >= q,
-    $lt: (v, q) => !Array.isArray(q) && v < q,
-    $lte: (v, q) => !Array.isArray(q) && v <= q,
-    $in: (v, q) => Array.isArray(v) ? v.some(item => q.includes(item)) : q.includes(v),
-    $nin: (v, q) => !(Array.isArray(v) ? v.some(item => q.includes(item)) : q.includes(v))
-};
-
-function refCondition(value, condition) {
-    const isOps = condition !== null && typeof condition === 'object' && !Array.isArray(condition)
-        && Object.keys(condition).length > 0 && Object.keys(condition).every(k => k.startsWith('$'));
-    if(!isOps) return value === condition;
-    return Object.entries(condition).every(([op, arg]) => op === '$not' ? !refCondition(value, arg) : compare[op](value, arg));
-}
-
-function refMatch(doc, query) {
-    return Object.entries(query).every(([key, value]) => {
-        if(key === '$and') return value.every(q => refMatch(doc, q));
-        if(key === '$or') return value.some(q => refMatch(doc, q));
-        if(key === '$nor') return !value.some(q => refMatch(doc, q));
-        return refCondition(doc[key], value);
-    });
-}
-
-// ---- random nested queries
-function randomQueryGenerator(random) {
-    const pick = list => list[Math.floor(random() * list.length)];
-    const fields = {
-        name: () => pick(NAMES),
-        city: () => pick(CITIES),
-        age: () => 18 + Math.floor(random() * 50),
-        score: () => Math.round(random() * 1000) / 10,
-        active: () => random() > 0.5,
-        tags: () => pick(TAGS),
-        nickname: () => random() > 0.3 ? pick(NAMES) : null
-    };
-
-    function condition(field) {
-        const value = fields[field];
-        const roll = random();
-        if(roll < 0.2) return value();                                            // plain equality
-        const ops = {};
-        const count = 1 + Math.floor(random() * 2);
-        for(let i = 0; i < count; i++) {
-            const op = pick(['$eq', '$ne', '$gt', '$gte', '$lt', '$lte', '$in', '$nin']);
-            ops[op] = op === '$in' || op === '$nin' ? [value(), value()] : value();
-        }
-        return roll > 0.85 ? { $not: ops } : ops;
-    }
-
-    function node(depth) {
-        const query = {};
-        const fieldNames = Object.keys(fields).sort(() => random() - 0.5).slice(0, 1 + Math.floor(random() * 2));
-        for(const field of fieldNames) query[field] = condition(field);
-        if(depth < 3 && random() > 0.4) {
-            const logical = pick(['$and', '$or', '$nor']);
-            query[logical] = Array.from({ length: 1 + Math.floor(random() * 3) }, () => node(depth + 1));
-        }
-        return query;
-    }
-
-    return () => node(0);
-}
-
-describe('SORLA find() matches the reference query semantics', () => {
-    let collection;
-    let documents;
-
-    beforeAll(() => {
-        documents = buildDocuments(prng(2026), 120);
-        const srla = new sorla();
-        srla.useDb('equivalence');
-        srla.db.createCollection('people');
-        // insertOne mutates the object (adds _id), keep the reference documents clean
-        for(const doc of documents) srla.db.people.insertOne(structuredClone(doc));
-        collection = srla.db.people;
-    });
-
-    const found = query => {
-        const cursor = collection.find(query);
-        const ids = [];
-        while(cursor.hasNext()) ids.push(cursor.next()._data.n);
-        return ids;
-    };
-    const expected = query => documents.filter(doc => refMatch(doc, query)).map(doc => doc.n);
-
-    const handWritten = [
-        {},
-        { city: 'A' },
-        { age: { $gte: 30, $lt: 40 } },
-        { tags: { $in: ['ops'] } },
-        { nickname: null },
-        { nickname: { $ne: null } },
-        { age: { $nin: [20, 21, 22] }, active: true },
-        { $or: [{ city: 'A' }, { city: 'B', age: { $gt: 50 } }] },
-        { $and: [{ age: { $gte: 30 } }, { $or: [{ name: 'Ana' }, { city: { $in: ['A', 'B'] } }] }] },
-        { $nor: [{ active: true }, { score: { $lt: 50 } }] },
-        { score: { $not: { $gte: 20, $lte: 80 } } },
-        { $or: [{ $and: [{ city: 'C' }, { $nor: [{ age: { $lt: 30 } }] }] }, { tags: { $in: ['admin'] }, active: false }] }
-    ];
-
-    handWritten.forEach((query, i) => {
-        it(`hand written query #${i + 1}: ${JSON.stringify(query)}`, () => {
-            expect(found(query)).to.deep.equal(expected(query));
-        });
-    });
-
-    it('500 random nested queries give the same documents as the reference', () => {
-        const next = randomQueryGenerator(prng(42));
-        let nonEmpty = 0;
-        for(let i = 0; i < 500; i++) {
-            const query = next();
-            const want = expected(query);
-            if(want.length) nonEmpty++;
-            expect(found(query), JSON.stringify(query)).to.deep.equal(want);
-        }
-        // the generator must produce meaningful queries, not only empty results
-        expect(nonEmpty).to.be.greaterThan(100);
-    });
-
-    it('findOne returns the first matching document', () => {
-        const query = { $and: [{ city: 'B' }, { $or: [{ active: true }, { age: { $gt: 40 } }] }] };
-        const first = expected(query)[0];
-        expect(collection.findOne(query).n).to.equal(first);
-    });
-});

package/test/unit_database.test.js

@@ -1,36 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const faker = require('faker')
-const sorla = require('../src/sorla.js')
-const collection = require('../src/collections/collection.js');
-
-describe('SORLA Database Unit Test', () => {
-    beforeAll(() => {
-        this.srla = new sorla();
-        this.dbname = faker.random.word();
-        this.srla.createDb(this.dbname);
-        this.srla.useDb(this.dbname);
-    });
-
-    it('Should create a new collection with specified name', () => {
-        this.srla.db.createCollection('collection1');
-        expect(this.srla.db.countCollections()).to.equal(1);
-        expect(this.srla.db.collection1).to.not.be.undefined;
-        expect(this.srla.db.collection1).to.be.an.instanceof(collection);
-    });
-
-    it('Should create a new collection with specified name, second collection', () => {
-        this.srla.db.createCollection('collection2');
-        expect(this.srla.db.countCollections()).to.equal(2);
-        expect(this.srla.db.collection2).to.not.be.undefined;
-        expect(this.srla.db.collection2).to.be.an.instanceof(collection);
-    });
-
-    it('Should return a collection undefined when not exists', () => {
-        expect(this.srla.db.collection3).to.be.undefined;
-    });
-
-    it('Should avoid create a collection with name that exists in database class', () => {
-        expect(() => this.srla.db.createCollection('_name')).to.throw();
-    });
-});

package/test/unit_document.test.js

@@ -1,39 +0,0 @@
-const chai = require('chai');
-const expect = chai.expect;
-const faker = require('faker');
-const documents = require('../src/documents/document.js');
-
-describe('testing document capabilities', () => {
-    it('checking capabilities of getting a field inside a object', () => {
-        const doc = new documents({
-            name: 'Anderson',
-            test: {
-                inscription: 123
-            }
-        });
-        
-        expect(doc.name).to.equal('Anderson');
-    });
-
-    it('checking capabilities of getting a field inside a object', () => {
-        const doc = new documents({
-            name: 'Anderson',
-            test: {
-                inscription: 123
-            }
-        });
-        
-        expect(doc.test.inscription).to.equal(123);
-    });
-
-    it('checking capabilities of getting a field inside a object', () => {
-        const doc = new documents({
-            name: 'Anderson',
-            test: {
-                inscription: 123
-            }
-        });
-        
-        expect(doc['test.inscription']).to.equal(123);
-    });
-});

package/test/unit_operators.test.js

@@ -1,78 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const operators = require('../src/query_language/operators.js')
-
-describe('SORLA comparison operators', () => {
-    const op = new operators();
-
-    it('recognizes logical and comparison operators', () => {
-        for(const name of ['$and', '$or', '$not', '$nor'])
-            expect(op.isLogicalOperator(name)).to.equal(true);
-        for(const name of ['$eq', '$ne', '$gt', '$gte', '$lt', '$lte', '$in', '$nin'])
-            expect(op.isOperator(name)).to.equal(true);
-        expect(op.isAnyOperator('$regex')).to.equal(false);
-        expect(op.isAnyOperator('name')).to.equal(false);
-    });
-
-    it('$eq is strict', () => {
-        expect(op.$eq(1, 1)).to.equal(true);
-        expect(op.$eq('1', 1)).to.equal(false);
-        expect(op.$eq(null, null)).to.equal(true);
-        expect(op.$eq(undefined, null)).to.equal(false);
-        expect(op.$eq(true, 1)).to.equal(false);
-        expect(op.$eq([1], [1]), 'arrays are not compared').to.equal(false);
-    });
-
-    it('$ne is the negation of $eq for scalars', () => {
-        expect(op.$ne(1, 2)).to.equal(true);
-        expect(op.$ne(1, 1)).to.equal(false);
-        expect(op.$ne(undefined, 1), 'missing field').to.equal(true);
-    });
-
-    it('range operators compare numbers, strings and ISO dates', () => {
-        expect(op.$gt(5, 3)).to.equal(true);
-        expect(op.$gte(3, 3)).to.equal(true);
-        expect(op.$lt(2, 3)).to.equal(true);
-        expect(op.$lte(3, 3)).to.equal(true);
-        expect(op.$gt('b', 'a')).to.equal(true);
-        expect(op.$lt('2026-01-31', '2026-02-01')).to.equal(true);
-        expect(op.$gt(undefined, 0), 'missing field').to.equal(false);
-        expect(op.$lt(undefined, 10), 'missing field').to.equal(false);
-    });
-
-    it('range operators reject arrays as the operand', () => {
-        for(const name of ['$gt', '$gte', '$lt', '$lte', '$eq', '$ne'])
-            expect(op[name](1, [1, 2]), name).to.equal(false);
-    });
-
-    it('$in and $nin work with scalar and array fields', () => {
-        expect(op.$in('a', ['a', 'b'])).to.equal(true);
-        expect(op.$in('c', ['a', 'b'])).to.equal(false);
-        expect(op.$in(['x', 'b'], ['a', 'b']), 'array field shares a value').to.equal(true);
-        expect(op.$in(['x'], ['a', 'b'])).to.equal(false);
-        expect(op.$in(1, ['1']), 'strict').to.equal(false);
-        expect(op.$nin('c', ['a', 'b'])).to.equal(true);
-        expect(op.$nin(undefined, ['a']), 'missing field').to.equal(true);
-    });
-
-    it('$in and $nin require an array', () => {
-        expect(() => op.$in('a', 'a')).to.throw('$in operator must be an array');
-        expect(() => op.$nin('a', 'a')).to.throw('$nin operator must be an array');
-    });
-
-    it('matchesCondition treats plain values as equality and objects of operators as conditions', () => {
-        expect(op.matchesCondition(5, 5)).to.equal(true);
-        expect(op.matchesCondition(5, { $gt: 1, $lt: 10 })).to.equal(true);
-        expect(op.matchesCondition(5, { $gt: 1, $lt: 4 })).to.equal(false);
-        expect(op.matchesCondition(5, { $not: { $gt: 10 } })).to.equal(true);
-        expect(op.matchesCondition({ a: 1 }, { a: 1 }), 'objects are not deep compared').to.equal(false);
-    });
-
-    it('isOperatorObject only accepts non empty objects made of operators', () => {
-        expect(op.isOperatorObject({ $gt: 1 })).to.equal(true);
-        expect(op.isOperatorObject({ $gt: 1, name: 2 })).to.equal(false);
-        expect(op.isOperatorObject({})).to.equal(false);
-        expect(op.isOperatorObject(null)).to.equal(false);
-        expect(op.isOperatorObject([1])).to.equal(false);
-    });
-});

package/test/unit_sorla.test.js

@@ -1,42 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const faker = require('faker')
-
-const sorla = require('../src/sorla.js')
-
-describe('SORLA Unit Test', () => {
-    it('Should create a new database with random name', () => {
-        const srla = new sorla();
-        const dbname = faker.random.word();
-        srla.createDb(dbname);
-        srla.useDb(dbname);
-
-        expect(srla.countDb()).to.equal(1);
-        expect(srla.dbExists(dbname)).to.equal(true);
-        expect(srla.db.name).to.equal(dbname);
-    });
-
-    it('Should not create a new database with the same name', () => {
-        const srla = new sorla();
-        const dbname = faker.random.word();
-        srla.createDb(dbname);
-
-        expect(srla.createDb(dbname)).to.equal(false);
-    });
-
-    it('Should created more than one database', () => {
-        const srla = new sorla();
-        for(let i=0; i<2; i++)
-        {
-            const dbname = faker.random.word();
-            srla.createDb(dbname);
-        }
-
-        expect(srla.countDb()).to.equal(2);
-    });
-
-    it('Should not have any database created', () => {
-        const srla = new sorla();
-        expect(srla.countDb()).to.equal(0);
-    });
-});

package/test/unit_test.test.js

@@ -1,25 +0,0 @@
-const chai = require('chai');
-const expect = chai.expect;
-
-const sorla = require('../src/sorla.js');
-
-describe('Sorla Class', () => {
-    it('should create a new database', () => {
-        const srla = new sorla();
-        srla.createDb('test');
-        expect(srla.countDb()).to.equal(1);
-    });
-
-    it('should not create a new database with the same name', () => {
-        const srla = new sorla();
-        srla.createDb('test');
-        expect(srla.createDb('test')).to.equal(false);
-    });
-
-    it('should created a new database and select it', () => {
-        const srla = new sorla();
-        const dbname = 'test';
-        srla.useDb(dbname);
-        expect(srla.db.name).to.equal(dbname);
-    });
-});

package/webpack.config.js

@@ -1,11 +0,0 @@
-const path = require('path');
-
-module.exports = {
-    mode: "production",
-    target: "web",
-    entry: './src/sorla.js',
-    output: {
-        path: path.resolve(__dirname, 'dist'),
-        filename: 'sorla.min.js'
-    }
-}