sorla-db 1.1.0 → 1.3.0

package/src/query_language/update.js

@@ -0,0 +1,167 @@
+/**
+ * Update operators: $set, $unset, $inc, $push and $pull, with "a.b" paths.
+ * Updates are applied to a copy of the document, so a failing operator never leaves it half updated.
+ */
+const UPDATE_OPERATORS = ['$set', '$unset', '$inc', '$push', '$pull'];
+
+const isPlainObject = value => value !== null && typeof value === 'object' && !Array.isArray(value)
+    && Object.prototype.toString.call(value) === '[object Object]';
+
+function splitPath(path)
+{
+    if(typeof path !== 'string' || path === '' || path.split('.').some(part => part === ''))
+        throw new Error(`Invalid field path "${path}"`);
+
+    if(path === '_id' || path.startsWith('_id.'))
+        throw new Error('The _id field cannot be updated');
+
+    return path.split('.');
+}
+
+function getPath(data, parts)
+{
+    let value = data;
+    for(const part of parts)
+    {
+        if(value === null || typeof value !== 'object' || !(part in value))
+            return undefined;
+
+        value = value[part];
+    }
+    return value;
+}
+
+/**
+ * Parent object of a path, creating missing objects on the way
+ */
+function parentOf(data, parts, create)
+{
+    let target = data;
+    for(const part of parts.slice(0, -1))
+    {
+        if(!(part in target))
+        {
+            if(!create) return null;
+            target[part] = {};
+        }
+
+        if(target[part] === null || typeof target[part] !== 'object')
+            throw new Error(`Cannot create the field "${parts.join('.')}": "${part}" is not an object`);
+
+        target = target[part];
+    }
+    return target;
+}
+
+/**
+ * Validates an update document
+ * @param object update
+ * @return void
+ */
+function validateUpdate(update)
+{
+    if(!isPlainObject(update))
+        throw new Error('The update must be an object like {$set: {field: value}}');
+
+    const keys = Object.keys(update);
+    if(!keys.length)
+        throw new Error('The update must contain at least one operator');
+
+    for(const key of keys)
+    {
+        if(!key.startsWith('$'))
+            throw new Error(`The update can only contain operators, use replaceOne() to replace a document (found "${key}")`);
+
+        if(!UPDATE_OPERATORS.includes(key))
+            throw new Error(`Unknown update operator ${key}`);
+
+        if(!isPlainObject(update[key]))
+            throw new Error(`The ${key} operator must be an object like {${key}: {field: value}}`);
+    }
+}
+
+/**
+ * Applies an update to a copy of the data
+ * @param object data stored document data
+ * @param object update
+ * @param object helpers {copy(value), validateKeys(object), operators}
+ * @return object the updated copy
+ */
+function applyUpdate(data, update, helpers)
+{
+    validateUpdate(update);
+    const result = helpers.copy(data);
+
+    for(const [path, value] of Object.entries(update.$set ?? {}))
+    {
+        const parts = splitPath(path);
+        if(value !== null && typeof value === 'object' && !helpers.validateKeys(Array.isArray(value) ? { value } : value))
+            throw new Error('Invalid document keys');
+
+        parentOf(result, parts, true)[parts.at(-1)] = helpers.copy(value);
+    }
+
+    for(const path of Object.keys(update.$unset ?? {}))
+    {
+        const parts = splitPath(path);
+        const parent = parentOf(result, parts, false);
+        if(parent && !Array.isArray(parent))
+            delete parent[parts.at(-1)];
+    }
+
+    for(const [path, amount] of Object.entries(update.$inc ?? {}))
+    {
+        const parts = splitPath(path);
+        if(typeof amount !== 'number' || !Number.isFinite(amount))
+            throw new Error(`$inc needs a number for "${path}"`);
+
+        const current = getPath(result, parts);
+        if(current !== undefined && typeof current !== 'number')
+            throw new Error(`Cannot $inc "${path}": it is not a number`);
+
+        parentOf(result, parts, true)[parts.at(-1)] = (current ?? 0) + amount;
+    }
+
+    for(const [path, value] of Object.entries(update.$push ?? {}))
+    {
+        const parts = splitPath(path);
+        const current = getPath(result, parts);
+        if(current !== undefined && !Array.isArray(current))
+            throw new Error(`Cannot $push to "${path}": it is not an array`);
+
+        const items = isPlainObject(value) && Array.isArray(value.$each) ? value.$each : [value];
+        for(const item of items)
+        {
+            if(item !== null && typeof item === 'object' && !helpers.validateKeys(Array.isArray(item) ? { item } : item))
+                throw new Error('Invalid document keys');
+        }
+        parentOf(result, parts, true)[parts.at(-1)] = [...(current ?? []), ...items.map(helpers.copy)];
+    }
+
+    for(const [path, condition] of Object.entries(update.$pull ?? {}))
+    {
+        const parts = splitPath(path);
+        const current = getPath(result, parts);
+        if(current === undefined)
+            continue;
+
+        if(!Array.isArray(current))
+            throw new Error(`Cannot $pull from "${path}": it is not an array`);
+
+        const { operators } = helpers;
+        const matches = item => {
+            if(operators.isRegExp(condition) || operators.isOperatorObject(condition))
+                return operators.matchesCondition(item, condition);
+
+            if(isPlainObject(condition))
+                return isPlainObject(item) && operators.matches(item, condition);
+
+            return item === condition;
+        };
+        parentOf(result, parts, false)[parts.at(-1)] = current.filter(item => !matches(item));
+    }
+
+    return result;
+}
+
+module.exports = { applyUpdate, validateUpdate, UPDATE_OPERATORS };

package/src/sorla.js

@@ -103,6 +103,33 @@ class sorla{
         return this._dbs.length;
     }
 
+    /**
+     * Names of the databases, in creation order
+     * @return array
+     */
+    listDatabases()
+    {
+        return this._dbs.map(db => db.name);
+    }
+
+    /**
+     * Removes a database and its collections; when it was selected, no database stays selected
+     * @param string name
+     * @return boolean false when it did not exist
+     */
+    dropDb(name)
+    {
+        const pos = this._findDbIndex(name);
+        if(pos === -1)
+            return false;
+
+        if(this._selectedDb === this._dbs[pos])
+            this._selectedDb = null;
+
+        this._dbs.splice(pos, 1);
+        return true;
+    }
+
     /**
      * Return selected db
      * @author Anderson Arruda < anderson@sysborg.com.br >

package/src/utils.js

@@ -25,16 +25,17 @@ class utils
      */
     getDotData(data, field)
     {
-        let fields = field.split('.');
+        let value = data;
+        for(const part of field.split('.'))
+        {
+            // a missing step means the field does not exist (it used to return the parent object)
+            if(value === null || typeof value !== 'object' || !(part in value))
+                return undefined;
 
-        fields.forEach(field => {
-            if(typeof data[field] !== 'undefined')
-            {
-                data = data[field];
-            }
-        });
+            value = value[part];
+        }
 
-        return data;
+        return value;
     }
 }
 

package/Brainstorming.md

@@ -1,22 +0,0 @@
-For the first query version needs only to see if has some non logical operator or non logical comparison to resend to find as a recursive method.
-
-- Preparing sort of data using new capabilities
-- improving find behavior
-
-For comparison operators and deny operator like not
-adding nor https://www.mongodb.com/docs/manual/reference/operator/query/nor/
-
-https://www.mongodb.com/docs/manual/reference/operator/query-comparison/
-https://www.mongodb.com/docs/manual/reference/operator/query/expr/
-https://www.mongodb.com/docs/manual/reference/operator/query/regex/
-
-
-Preparing a bunch of misc tests to search data, add sort data and create test sortable data.
-
-//erros and improvements
-Bugs appears after resolving not, need to check and test why
-npm run test
-
-needs to improve projection to use cursor
-
-fix new bugs in test

package/debug-not.js

@@ -1,24 +0,0 @@
-const sorla = require('./src/sorla.js');
-const helper = require('./src/helper.js');
-
-const numberOfObjects = 20;
-const sdb = new sorla();
-sdb.createDb('test');
-sdb.useDb('test');
-
-sdb.db.createCollection('collection_test');
-
-const objects = helper.createFakeCollection(sdb, 'collection_test', numberOfObjects);
-const [itemIndex1, ] = helper.getRandomComparisonData(objects);
-
-const finded = sdb.db.collection_test.find({
-    uuid: {
-        $not: {
-            $eq: itemIndex1.uuid
-        }
-    }
- });
-
- console.log(finded.length, numberOfObjects);
-
-//console.log(finded);

package/example/simple_data_example.html

@@ -1,196 +0,0 @@
-<!DOCTYPE html>
-<html>
-    <head>
-        <meta charset="UTF-8">
-        <title>Simple Data Example</title>
-        <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    </head>
-    <body>
-        <p><b>Total Items:</b> <span id="total-items"></span></p><hr>
-
-        <h3>Add you data:</h3>
-        <div>
-            <label>Name</label>
-            <input type="text" id="name" placeholder="Name">
-        </div>
-        <div>
-            <label>Inscription</label>
-            <input type="number" step="1" min="1" id="inscription" placeholder="Inscription">
-        </div>
-        <div>
-            <label>Age</label>
-            <input type="number" step="1" min="1" id="age" placeholder="Age">
-        </div>
-        <div>
-            <label>Father</label>
-            <input type="text" id="father" placeholder="Father">
-        </div>
-        <div>
-            <label>Mother</label>
-            <input type="text" id="mother" placeholder="Mother">
-        </div>
-        <button type="button" id="add-data">Add data</button>
-        <hr>
-
-        <h3>Seach data</h3>
-        <div>
-            <label>Search by</label>
-            <input type="text" id="search-name" placeholder="Search by">
-            <select id="search-name-type">
-                <option value="name">Name</option>
-                <option value="inscription">Inscription</option>
-                <option value="age">Age</option>
-                <option value="parents.father">Father</option>
-                <option value="parents.mother">Mother</option>
-            </select>
-            <button type="button" id="search-by-btn">Search</button>
-        </div>
-
-        <div>
-            <textarea id="search-result" cols="30" rows="10"></textarea>
-        </div>
-
-        <script src="../dist/sorla.min.js"></script>
-
-        <script>
-            function generateUUID() {
-                return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
-                    var r = Math.random() * 16 | 0,
-                        v = c == 'x' ? r : (r & 0x3 | 0x8);
-                    return v.toString(16);
-                });
-            }
-
-            addItem = () => {
-                const name = document.getElementById('name').value;
-                const inscription = document.getElementById('inscription').value;
-                const age = document.getElementById('age').value;
-                const father = document.getElementById('father').value;
-                const mother = document.getElementById('mother').value;
-
-                s.db.simple.insertOne({
-                    'name': name,
-                    'inscription': inscription,
-                    'age': age,
-                    'parents': {
-                        'father': father,
-                        'mother': mother
-                    }
-                });
-
-                document.getElementById('total-items').innerText = s.db.simple.count();
-            }
-
-            searchData = () => {
-                const searchName = document.getElementById('search-name').value;
-                const searchNameType = document.getElementById('search-name-type').value;
-
-                const result = s.db.simple.findOne({
-                    [searchNameType]: searchName
-                });
-
-                console.log(result);
-
-                document.getElementById('search-result').value = JSON.stringify(result, null, 4);
-            }
-
-            document.addEventListener('DOMContentLoaded', () => {
-                window.s = new sorla();
-                s.useDb('simple_database');
-                s.db.createCollection('simple');
-                const uuid_fix = generateUUID();
-
-                //creating data
-                s.db.simple.insertMany([
-                    {
-                        'name': 'John Doe',
-                        'inscription': 123,
-                        'age': 25,
-                        'parents': {
-                            'father': 'John Doe Sr.',
-                            'mother': 'Jane Doe'
-                        },
-                        'uuid': generateUUID()
-                    },
-
-                    {
-                        "name": "Elizabeth Davis",
-                        "inscription": 618,
-                        "age": 36,
-                        "parents": {
-                            "father": "Elizabeth Brown",
-                            "mother": "Elizabeth Brown"
-                        },
-                        'uuid': generateUUID()
-                    },
-
-
-                    {
-                        "name": "John Davis",
-                        "inscription": 817,
-                        "age": 54,
-                        "parents": {
-                            "father": "John Garcia",
-                            "mother": "Patricia Garcia"
-                        },
-                        'uuid': uuid_fix
-                    },
-
-                    {
-                        "name": "Jennifer Miller",
-                        "inscription": 699,
-                        "age": 45,
-                        "parents": {
-                            "father": "Linda Brown",
-                            "mother": "Elizabeth Brown"
-                        },
-                        'uuid': generateUUID()
-                    },
-
-                    {
-                        "name": "Patricia Johnson",
-                        "inscription": 906,
-                        "age": 49,
-                        "parents": {
-                            "father": "Robert Johnson",
-                            "mother": "Elizabeth Johnson"
-                        },
-                        'uuid': generateUUID()
-                    },
-
-                    {
-                        "name": "Michael Johnson",
-                        "inscription": 810,
-                        "age": 20,
-                        "parents": {
-                            "father": "Jennifer Brown",
-                            "mother": "Jennifer Brown"
-                        },
-                        'uuid': generateUUID()
-                    }
-                ]);
-
-                document.getElementById('total-items').innerText = s.db.simple.count();
-                document.getElementById('add-data').addEventListener('click', addItem);
-                document.getElementById('search-by-btn').addEventListener('click', searchData);
-
-                //operators test
-                //testing search and
-                /*const result = s.db.simple.find({'$and': [{'name': 'John Doe'}, {'age': 25}]}, {_id: 0}); //should return 1
-                console.log('and', result);
-
-                //testing search or
-                const result2 = s.db.simple.find({'$or': [{'name': 'John Doe'}, {'parents.mother': 'Elizabeth Johnson'}]}); //should return 2
-                console.log('or', result2);
-
-                //testing search uuid
-                const result3 = s.db.simple.findOne({'uuid': uuid_fix});
-                console.log('uuid', uuid_fix, result3);*/
-
-                //search uuid with not
-                const result4 = s.db.simple.find({'uuid': {'$not': uuid_fix}});
-                console.log('uuid not', uuid_fix, result4);
-            });
-        </script>
-    </body>
-</html>

package/index.js

@@ -1,62 +0,0 @@
-
-const fs = require('fs-extra');
-const browserify = require('browserify');
-const path = require('path');
-const terser = require('terser');
-
-const srcDir = './src';
-const distDir = './dist';
-const outputFile = `${distDir}/sorla.min.js`;
-
-function findJsFiles(dir, fileList = [])
-{
-    const files = fs.readdirSync(dir);
-    files.forEach(file => {
-        const filePath = path.join(dir, file);
-        const stat = fs.statSync(filePath);
-        if (stat.isDirectory())
-        {
-            findJsFiles(filePath, fileList);
-        }
-        else if (path.extname(filePath) === '.js')
-        {
-            fileList.push(filePath);
-        }
-    });
-    return fileList;
-}
-
-function buildForBrowser(entryFile, outputFile) {
-    const b = browserify();
-    b.add(entryFile);
-    b.bundle(async (err, buf) => {
-        if (err) {
-            console.error(err);
-            return;
-        }
-
-        const code = buf.toString();
-        try {
-            const minified = await terser.minify(code, {
-                compress: true,
-                mangle: {
-                    keep_classnames: true,
-                    keep_fnames: true
-                }
-            });
-
-            if (minified.error) {
-                console.error(minified.error);
-                return;
-            }
-
-            fs.outputFileSync(outputFile, code);
-            fs.outputFileSync(outputFile, minified.code);
-        } catch (minifyErr) {
-            console.error(minifyErr);
-        }
-    });
-}
-
-const allJsFiles = findJsFiles(srcDir);
-buildForBrowser(allJsFiles, outputFile);

package/src/helper.js

@@ -1,41 +0,0 @@
-//this file works only in dev mode, and is used to help with the development of the app
-//and to debug bad behaviors and mistakes
-
-const faker = require('faker');
-const sorla = require('./sorla.js');
-
-const createFakeCollection = (srla, collectionName, number_objects) => {
-    if(!(srla instanceof sorla))
-        throw new Error('srla must be an instance of sorla');
-
-    const objects = [];
-
-    for(let i=0; i<number_objects; i++)
-    {
-        const obj = {
-            name: faker.random.word(),
-            email: faker.internet.email(),
-            age: faker.datatype.number(),
-            uuid: faker.datatype.uuid()
-        };
-        srla.db[collectionName].insertOne(structuredClone(obj));
-        objects.push(obj);
-    }
-
-    return objects;
-}
-
-const getRandomComparisonData = (objects) => {
-    const itemIndex1 = Math.floor(Math.random() * objects.length);
-    let itemIndex2 = null;
-    do {
-        itemIndex2 = Math.floor(Math.random() * objects.length);
-    } while(itemIndex1 === itemIndex2);
-
-    return [objects[itemIndex1], objects[itemIndex2]];
-}
-
-module.exports = {
-    createFakeCollection,
-    getRandomComparisonData
-}

package/test/feature_collection.test.js

@@ -1,75 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const faker = require('faker')
-const sorla = require('../src/sorla.js')
-
-describe('SORLA Collection Feature Test', () => {
-    beforeAll(() => {
-        this.srla = new sorla();
-        this.dbname = faker.random.word();
-        this.srla.createDb(this.dbname);
-        this.srla.useDb(this.dbname);
-    });
-
-    let sequence = 0;
-    beforeEach(() => {
-        // random words repeat or clash with database properties ("name"), so make them unique
-        this.collectionName = `collection_${++sequence}`;
-        this.srla.db.createCollection(this.collectionName);
-    });
-
-    it('Create a single document inside of a collection and check by length', () => {
-        this.srla.db[this.collectionName].insertOne({name: 'Anderson'});
-        expect(this.srla.db[this.collectionName].count()).to.equal(1);
-    });
-
-    it('create multiple documents and check by length', () => {
-        this.srla.db[this.collectionName].insertMany([
-            {name: 'Anderson'},
-            {name: 'Arruda'},
-            {name: 'Sorla'}
-        ]);
-        expect(this.srla.db[this.collectionName].count()).to.equal(3);
-    });
-
-    it('create a document with prohibited character $', () => {
-        expect(() => this.srla.db[this.collectionName].insertOne({name: 'Anderson', $test: '123'})).to.throw();
-    });
-
-    it('create a document with prohibited character .', () => {
-        expect(() => this.srla.db[this.collectionName].insertOne({"name.name": 'Anderson', test: {test: '123'}})).to.throw();
-    });
-
-    it('create a document with prohibited character . inside of an array', () => {
-        expect(() => this.srla.db[this.collectionName].insertOne({name: 'Anderson', test: [{"test.number": '123'}, {"test.number": '123'}]})).to.throw();
-    });
-
-    it('create a document with prohibited character . inside of an object', () => {
-        expect(() => this.srla.db[this.collectionName].insertOne({name: 'Anderson', test: {"test.number": '123'}})).to.throw();
-    });
-
-    /*it('get a document by his subfield using test.inscription', () => {
-        this.srla.db[this.collectionName].insertMany([
-            {name: 'Anderson', test: {inscription: 123}},
-            {name: 'Arruda', test: {inscription: 321}},
-            {name: 'Sorla', test: {inscription: 213}}
-        ]);
-        expect(this.srla.db[this.collectionName].findOne({'test.inscription': 123}).length).to.equal(1);
-    });
-
-    it('Try to create a document without beeing a valid object', () => {
-        expect(() => this.srla.db[this.collectionName].insertOne('Anderson')).to.throw();
-    });
-
-    it('Try to create a document with array', () => {
-        expect(() => this.srla.db[this.collectionName].insertOne(['Anderson'])).to.throw();
-    });
-
-    it('Try to create many documents without beeing a valid array', () => {
-        expect(() => this.srla.db[this.collectionName].insertMany('Anderson')).to.throw();
-    });
-
-    it('Try to create many documents without having valid object', () => {
-        expect(() => this.srla.db[this.collectionName].insertMany([{test: '123', }, 'anderson'])).to.throw();
-    });*/
-});