sorla-db 1.0.0

package/src/query_language/manipulation.js

@@ -0,0 +1,161 @@
+const documents = require('../documents/document.js');
+const operatorsCheck = require('./operators.js');
+
+class manipulation {
+    constructor(validationSchema = null) {
+        this.validationSchema = validationSchema;
+        this._index = {};
+        this._prohibitedCharacters = ['$', '.'];
+    }
+
+    /**
+     * Generates a unique key as a uuid
+     * @return string
+     */
+    _generateKey() {
+        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)
+        });
+    }
+
+    /**
+     * Valid and set validation schema for collection
+     * @author Anderson Arruda < anderson@sysborg.com.br >
+     * @version 1.0.0
+     * @param validationSchema
+     * @return void
+    **/
+    set validationSchema(validationSchema)
+    {
+        if(typeof schemaValidation === 'undefined' || schemaValidation === null)
+            return;
+
+        if(['object', 'function'].indexOf(typeof schemaValidation) == -1)
+        {
+            throw new Error('Invalid schema validation');
+        }
+
+        this._validationSchema = validationSchema;  
+    }
+
+    /**
+     * Validate data
+     * @param object data
+     * @return boolean
+     */
+    _validate(data) 
+    {
+        //under construction
+        return true;
+    }
+
+    /**
+     * Verify if exists some document that is not object
+     * @param array documents
+     * @return boolean
+     */
+    _validateDocumentsType(documents)
+    {
+        const count = documents.reduce((acc, doc) => {
+            return typeof doc !== 'object' ? ++acc : acc;
+        }, 0);
+
+        return count;
+    }
+
+    /**
+     * Verify if keys has prohibited characters
+     * @param object document
+     * @return boolean
+     */
+    _validateKeys(document)
+    {
+        const keys = Object.keys(document);
+        const operators = new operatorsCheck();
+        for(let key of keys)
+        {
+            const hasProhibitedCharacters = this._prohibitedCharacters.reduce((acc, char) => {
+                return key.indexOf(char) > -1 ? ++acc : acc;
+            }, 0);
+
+            if(hasProhibitedCharacters > 0 && !operators.isOperator(key))
+                return false;
+
+            if(typeof document[key] === 'object')
+                return this._validateKeys(document[key]);
+
+            if(Array.isArray(document[key]))
+            {
+                for(let value of document[key])
+                {
+                    if(typeof value === 'object')
+                        return this._validateKeys(value);
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Inserts one document to the collection
+     * @author Anderson Arruda < anderson@sysborg.com.br >
+     * @version 1.0.0
+     * @param object document
+     * @param function callback - under construction
+     * @return void
+    **/
+    insertOne(document, callback) 
+    {
+        if(typeof document !== 'object' || Array.isArray(document))
+            throw new Error('Invalid document type');
+
+        if(!this._validateKeys(document))
+            throw new Error('Invalid document keys');
+
+        if(typeof document._id === 'undefined')
+        {
+            let _idKey = '';
+            do {
+                _idKey = this._generateKey();
+            } while(this._documents.find(doc => doc._id === document._id));
+
+            document._id = _idKey;
+        }
+
+        if(!this._validate(document))
+            throw new Error('Invalid document');
+
+        this._documents.push(new documents(document));
+
+        if(typeof callback === 'function')
+            callback();
+    }
+
+    /**
+     * Insert many documents
+     * @author Anderson Arruda < anderson@sysborg.com.br >
+     * @version 1.0.0
+     * @param array documents 
+     * @param function callback 
+     * @return void
+     */
+    insertMany(documents, callback) {
+        console.info(this._validateDocumentsType(documents));
+        if(!Array.isArray(documents) || this._validateDocumentsType(documents) > 0)
+            throw new Error('Documents must be an array of objects');
+
+        for(let document of documents)
+            this.insertOne(document);
+
+        if(typeof callback === 'function')
+            callback();
+    }
+
+    //create index
+    //create indexes
+}
+
+module.exports = manipulation;

package/src/query_language/operators.js

@@ -0,0 +1,289 @@
+class operators {
+    /**
+     * Constructs the class and creates a property to store fieldname
+     */
+    constructor() {
+        this._currentField = null;
+        this._logicalOperators = ['$or', '$and', '$not', '$nor'];
+        this._comparisonOperators = ['$lt', '$lte', '$gt', '$gte', '$eq', '$ne', '$in', '$nin'];
+    }
+
+    /**
+     * Set current field
+     * @param string field
+     * @return void
+     */
+    set currentField(field) {
+        this._currentField = field;
+    }
+
+    /**
+     * Check if is any operator
+     * @param string operator
+     * @return boolean
+     */
+    isAnyOperator(operator) {
+        return this.isLogicalOperator(operator) || this.isOperator(operator);
+    }
+
+    /**
+     * check if is logical operator
+     * @param string operator
+     * @return boolean
+     */
+    isLogicalOperator(operator) {
+        return this._logicalOperators.indexOf(operator) > -1;
+    }
+
+    /**
+     * Is operators
+     * @param string operator
+     * @return boolean
+     */
+    isOperator(operator) {
+        return this._comparisonOperators.indexOf(operator) > -1;
+    }
+
+    /**
+     * Or operator
+     * @param array queries
+     * @param object doc
+     * @return array
+     */
+    get $or() {
+        return (queries, doc) => {
+            if(!Array.isArray(queries))
+                throw new Error('The $or operator must be an array');
+
+            let result = false;
+            queryLoop: for(const query of queries) {
+                for(const attr of Object.keys(query)) {
+                    if(this.isLogicalOperator(attr) && this[attr](query[attr], doc))
+                    {
+                        result = true;
+                        continue queryLoop;
+                    }
+
+                    if(this.handleComparison(attr, query[attr], doc))
+                    {
+                        result = true;
+                        continue queryLoop;
+                    }
+                }
+            }
+
+            return result;
+        };
+    }
+
+    /**
+     * And operator
+     * @param array queries
+     * @param object doc
+     * @return array
+     */
+    get $and() {
+        return (queries, doc) => {
+            if(!Array.isArray(queries))
+                throw new Error('The $and operator must be an array');
+
+            let result = true;
+            queryLoop: for(const query of queries) {
+                for(const attr of Object.keys(query)) {
+                    if(this.isLogicalOperator(attr) && !this[attr](query[attr], doc))
+                    {
+                        result = false;
+                        continue queryLoop;
+                    }
+
+                    if(!this.handleComparison(attr, query[attr], doc))
+                    {
+                        result = false;
+                        continue queryLoop;
+                    }
+                }
+            }
+
+            return result;
+        };
+    }
+
+    /**
+     * Not operator
+     * @param array queries
+     * @param object doc
+     * @return array
+     */
+    get $not() {
+        const self = this;
+        return (queries, doc) => {
+            if(typeof queries !== 'object')
+                throw new Error('The $not operator must be an object');
+
+            const handledComparison = self.handleComparison(this._currentField, queries, doc);
+            return !handledComparison;
+        };
+    }
+
+    /**
+     * Nor operator
+     * @param array queries
+     * @param object doc
+     * @return array
+     */
+    get $nor() {
+        return (queries, doc) => {
+            if(!Array.isArray(queries))
+                throw new Error('The $nor operator must be an array');
+
+            for(const query of queries) {
+                for(const attr of Object.keys(query)) {
+                    if(this.isLogicalOperator(attr) && this[attr](query[attr], doc))
+                        return false;
+
+                    if(this.handleComparison(attr, query[attr], doc))
+                        return false;
+                }
+            }
+
+            return true;
+        };
+    }
+
+    /**
+     * Not in operator
+     * @param mixed doc_value
+     * @param array queries
+     * @return boolean
+     */
+    get $nin() {
+        return (doc_value, queries) => {
+            if(!Array.isArray(queries))
+                throw new Error('The $nin operator must be an array');
+
+            return !this.$in(doc_value, queries);
+        }
+    }
+
+    /**
+     * In operator
+     * @param mixed doc_value
+     * @param array queries
+     * @return boolean
+     */
+    get $in() {
+        return (doc_value, queries) => {
+            if(!Array.isArray(queries))
+                throw new Error('The $in operator must be an array');
+
+            if(Array.isArray(doc_value))
+            {
+                for(const value of queries)
+                {
+                    if(doc_value.indexOf(value) > -1)
+                        return true;
+                }
+            }
+
+            return  queries.indexOf(doc_value) > -1;
+        }
+    }
+
+    /**
+     * less than
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $lt() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value < query : false;
+        }
+    }
+
+    /**
+     * less than or equal
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $lte() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value <= query : false;
+        }
+    }
+
+    /**
+     * greater than
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $gt() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value > query : false;
+        }
+    }
+
+    /**
+     * greater than or equal
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $gte() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value >= query : false;
+        }
+    }
+
+    /**
+     * not equal
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $ne() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value !== query : false;
+        }
+    }
+
+    /**
+     * equal
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $eq() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value === query : false;
+        };
+    }
+
+    /**
+     * Handling with comparison of columns
+     * @param string field
+     * @param mixed query
+     * @param object doc
+     * @return boolean
+     */
+    handleComparison(field, query, doc) {
+        if(typeof doc[field] === 'undefined' && typeof doc[this._currentField] === 'undefined')
+            return false;
+
+        if(this.isOperator(field))
+            return this[field](doc[this._currentField], query);
+
+        if(typeof query === 'object')
+        {
+            const operator = Object.keys(query)[0];
+            field = typeof field === 'undefined' ? this._currentField : field;
+            return this[operator](doc[field], query[operator]);
+        }
+
+        return this.$eq(doc[field], query);
+    }
+}
+
+module.exports = operators;

package/src/query_language/query.js

@@ -0,0 +1,104 @@
+const manipulation = require('./manipulation.js');
+const operators = require('./operators.js');
+const cursor = require('../documents/cursor.js');
+
+class query extends manipulation
+{
+    constructor(validationSchema)
+    {
+        super(validationSchema);
+        this._operators = new operators();
+    }
+
+    /**
+     * Count documents
+     * @return int
+     */
+    count()
+    {
+        return this._documents.length;
+    }
+
+    /**
+     * Deeps find in object
+     * @param object query
+     * @param object projection
+     * @param bool firstOne
+     * @return array
+     */
+    _deepFind(query, projection, single=false)
+    {
+        const c = new cursor();
+        const find = (documents, query, single, debug=false) => {
+            let finded = [];
+            const queryKeys = Object.keys(query);
+            docsLoop: for(let doc of documents)
+            {
+                for(let k of queryKeys)
+                {
+                    if(!this._operators.isAnyOperator(k))
+                    {
+                        this._operators.currentField = k;
+
+                        if(typeof query[k] === 'object')
+                        {
+                            if(find([doc], query[k], single).length === 0)
+                            {
+                                continue docsLoop;
+                            }
+
+                            continue;
+                        }
+                    }
+
+                    const isLogicalOperator = this._operators.isLogicalOperator(k);
+                    if((isLogicalOperator && !this._operators[k](query[k], doc)) || (!isLogicalOperator && !this._operators.handleComparison(k, query[k], doc)))
+                    {
+                        continue docsLoop;
+                    }
+                }
+
+                finded.push(doc.clone());
+                if(single) break;
+            }
+
+            return finded;
+        };
+
+        const result = find(this._documents, query, single);
+        const finded = new cursor(result, projection);
+
+        return finded;
+    }
+
+    /**
+     * Find one document
+     * @param query
+     * @param projection
+     * @return object
+     */
+    findOne(query, projection = null)
+    {
+        const finded = this._deepFind(query, projection, true);
+        return finded.first();
+    }
+
+    /**
+     * Find documents
+     * @param query
+     * @param projection
+     * @return array
+     */
+    find(query, projection = null)
+    {
+        const finded = this._deepFind(query, projection);
+        return finded;
+    }
+
+    //find
+    //find one and delete
+    //find one and update
+    //find one and replace
+}
+
+module.exports =  query;

package/src/sorla.js

@@ -0,0 +1,123 @@
+const database = require('./dbs/database.js');
+
+class sorla{
+    /**
+     * Constructs class Sorla to manage databases
+     * @author Anderson Arruda < andmarruda@gmail.com >
+     * @version 1.0.0
+     * @param 
+     * @return void
+     */
+    constructor()
+    {
+        this._dbs = [];
+        this._selectedDb = null;
+    }
+
+    /**
+     * Search a database`s position in the list of databases by its name and mark it as selected
+     * @author Anderson Arruda < andmarruda@gmail.com >
+     * @version 
+     * @param 
+     * @return 
+    **/
+    _findDbIndex(name)
+    {
+        return this._dbs.findIndex(db => db.name == name);
+    }
+
+    /**
+     * Verify if a database name already exists in the list of databases
+     * @author Anderson Arruda < andmarruda@gmail.com >
+     * @version 1.0.0
+     * @param  string name
+     * @return boolean
+     */
+    dbExists(name)
+    {
+        return this._findDbIndex(name) > -1;
+    }
+
+    /**
+     * Mark a database as selected
+     * @author Anderson Arruda < andmarruda@gmail.com >
+     * @version 1.0.0
+     * @param 
+     * @return 
+    **/
+    _selectDb(pos)
+    {
+        if(!this._dbs.hasOwnProperty(pos))
+        {
+            throw new Error('Database does not exists');
+        }
+        this._selectedDb = this._dbs[pos];
+    }
+
+    /**
+     * Creates a new database
+     * @author Anderson Arruda < andmarruda@gmail.com >
+     * @version 1.0.0
+     * @param string name
+     * @return int "The position of the new database in the list of databases"
+    **/
+    createDb(name)
+    {
+        if(this.dbExists(name))
+        {
+            return false;
+        }
+
+        let pos = this._dbs.length;
+        this._dbs.push(new database(name));
+        return pos;
+    }
+
+    /**
+     * Selects a database by its name or creates a new one if it does not exists and then selects it
+     * @author Anderson Arruda < andmarruda@gmail.com >
+     * @version 1.0.0
+     * @param string name
+     * @return void
+    **/
+    useDb(name)
+    {
+        let pos = null;
+        if(!this.dbExists(name))
+        {
+            pos = this.createDb(name);
+        }
+
+        this._selectDb(pos === null ? this._findDbIndex(name) : pos);
+    }
+
+    /**
+     * Get the number of created databases
+     * @author Anderson Arruda < andmarruda@gmail.com >
+     * @version 1.0.0
+     * @param 
+     * @return int
+    **/
+    countDb()
+    {
+        return this._dbs.length;
+    }
+
+    /**
+     * Return selected db
+     * @author Anderson Arruda < anderson@sysborg.com.br >
+     * @version 1.0.0
+     * @param 
+     * @return instanceof database
+    **/
+    get db()
+    {
+        return this._selectedDb;
+    }
+}
+
+module.exports = sorla;
+if(typeof window !== 'undefined')
+{
+    window.sorla = sorla;
+}

package/src/utils.js

@@ -0,0 +1,41 @@
+class utils
+{
+    /**
+     * Get a uuid v4 string
+     * @author Anderson Arruda < anderson@sysborg.com.br >
+     * @version 1.0.0
+     * @param 
+     * @return string
+    **/
+    get uuid()
+    {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c)
+        {
+            let r = Math.random() * 16 | 0,
+                v = c == 'x' ? r : (r & 0x3 | 0x8);
+
+            return v.toString(16);
+        });
+    }
+
+    /**
+     * Get data using dots to access subfields
+     * @param object data
+     * @param string field
+     */
+    getDotData(data, field)
+    {
+        let fields = field.split('.');
+
+        fields.forEach(field => {
+            if(typeof data[field] !== 'undefined')
+            {
+                data = data[field];
+            }
+        });
+
+        return data;
+    }
+}
+
+module.exports = utils;