sorla-db 1.2.0 → 1.4.0

package/src/query_language/manipulation.js

@@ -1,8 +1,12 @@
 const documents = require('../documents/document.js');
 const operatorsCheck = require('./operators.js');
+const emitter = require('../events.js');
+const { applyUpdate } = require('./update.js');
+const { compileSchema, ValidationError } = require('../schema/schema.js');
 
-class manipulation {
+class manipulation extends emitter {
     constructor(validationSchema = null) {
+        super();
         this.validationSchema = validationSchema;
         this._index = {};
         this._prohibitedCharacters = ['$', '.'];
@@ -21,34 +25,72 @@ class manipulation {
     }
 
     /**
-     * Valid and set validation schema for collection
+     * Sets the validation schema of the collection (JSON Schema subset or a function).
+     * Documents inserted, updated or replaced afterwards must satisfy it; existing ones are not checked.
      * @author Anderson Arruda < anderson@sysborg.com.br >
-     * @version 1.0.0
-     * @param validationSchema
+     * @version 1.4.0
+     * @param object|function|null validationSchema
      * @return void
     **/
     set validationSchema(validationSchema)
     {
-        if(typeof schemaValidation === 'undefined' || schemaValidation === null)
-            return;
-
-        if(['object', 'function'].indexOf(typeof schemaValidation) == -1)
+        if(validationSchema === null || typeof validationSchema === 'undefined')
         {
-            throw new Error('Invalid schema validation');
+            this._schema = null;
+            return;
         }
 
-        this._validationSchema = validationSchema;  
+        if(['object', 'function'].indexOf(typeof validationSchema) === -1 || Array.isArray(validationSchema))
+            throw new Error('The validation schema must be an object (JSON Schema) or a function');
+
+        this._schema = compileSchema(validationSchema);
+    }
+
+    /**
+     * The schema given to the collection, or null
+     * @return object|function|null
+     */
+    get validationSchema()
+    {
+        return this._schema ? this._schema.source : null;
     }
 
     /**
-     * Validate data
+     * @param object|function|null schema
+     * @return this
+     */
+    setSchema(schema)
+    {
+        this.validationSchema = schema;
+        return this;
+    }
+
+    getSchema()
+    {
+        return this.validationSchema;
+    }
+
+    /**
+     * Checks a document against the schema without storing it (e.g. to validate a form)
+     * @param object document
+     * @return object {valid, errors: [{path, rule, message}]}
+     */
+    validate(document)
+    {
+        const errors = this._schema ? this._schema.validate(document) : [];
+        return { valid: errors.length === 0, errors };
+    }
+
+    /**
+     * Throws a ValidationError when the data does not satisfy the schema
      * @param object data
-     * @return boolean
+     * @return void
      */
     _validate(data) 
     {
-        //under construction
-        return true;
+        const errors = this._schema ? this._schema.validate(data) : [];
+        if(errors.length)
+            throw new ValidationError(errors);
     }
 
     /**
@@ -124,6 +166,33 @@ class manipulation {
      * @return mixed the _id of the inserted document
     **/
     insertOne(document, callback) 
+    {
+        const id = this._insertDocument(document);
+        this._emitChange('insert', { ids: [id], documents: [this._copy(this._documents.at(-1)._data)] });
+
+        if(typeof callback === 'function')
+            callback(id);
+
+        return id;
+    }
+
+    /**
+     * Validates and stores one document, without events
+     * @param object document
+     * @return mixed the _id
+     */
+    _insertDocument(document)
+    {
+        return this._store(this._prepare(document));
+    }
+
+    /**
+     * Copy of a document ready to be stored: _id, schema defaults, keys and schema checked
+     * @param object document
+     * @param Set reserved ids taken by the same batch
+     * @return object
+     */
+    _prepare(document, reserved = null)
     {
         if(!this._isDocument(document))
             throw new Error('Invalid document type');
@@ -131,27 +200,38 @@ class manipulation {
         if(!this._validateKeys(document))
             throw new Error('Invalid document keys');
 
+        const taken = id => this._ids().has(id) || (reserved !== null && reserved.has(id));
         const data = this._copy(document);
         if(typeof data._id === 'undefined')
         {
             do {
                 data._id = this._generateKey();
-            } while(this._ids().has(data._id));
+            } while(taken(data._id));
         }
-        else if(this._ids().has(data._id))
+        else if(taken(data._id))
         {
             throw new Error(`Duplicate _id "${data._id}"`);
         }
 
-        if(!this._validate(data))
-            throw new Error('Invalid document');
+        if(this._schema)
+        {
+            this._schema.applyDefaults(data, value => this._copy(value));
+            if(!this._validateKeys(data))
+                throw new Error('Invalid document keys');
+        }
+
+        this._validate(data);
+        return data;
+    }
 
+    /**
+     * @param object data prepared document
+     * @return mixed the _id
+     */
+    _store(data)
+    {
         this._documents.push(new documents(data));
         this._ids().add(data._id);
-
-        if(typeof callback === 'function')
-            callback(data._id);
-
         return data._id;
     }
 
@@ -168,27 +248,242 @@ class manipulation {
         if(!Array.isArray(documents) || !documents.every(document => this._isDocument(document)))
             throw new Error('Documents must be an array of objects');
 
-        const given = new Set();
-        for(const document of documents)
+        // prepare (and validate) the whole batch before storing anything
+        const reserved = new Set();
+        const prepared = documents.map(document => {
+            const data = this._prepare(document, reserved);
+            reserved.add(data._id);
+            return data;
+        });
+
+        const start = this._documents.length;
+        const ids = prepared.map(data => this._store(data));
+        this._emitChange('insert', { ids, documents: this._documents.slice(start).map(doc => this._copy(doc._data)) });
+
+        if(typeof callback === 'function')
+            callback(ids);
+
+        return ids;
+    }
+
+    /**
+     * Helpers the update operators need
+     * @return object
+     */
+    _updateHelpers()
+    {
+        return {
+            copy: value => this._copy(value),
+            validateKeys: value => this._validateKeys(value),
+            operators: this._operators
+        };
+    }
+
+    /**
+     * Document for an upsert: the equality conditions of the filter, then the update
+     * @param object filter
+     * @return object
+     */
+    _upsertBase(filter)
+    {
+        const base = {};
+        for(const [key, value] of Object.entries(filter))
         {
-            if(!this._validateKeys(document))
-                throw new Error('Invalid document keys');
+            // only top level equality conditions describe the new document
+            if(key.startsWith('$') || key.includes('.') || this._operators.isRegExp(value))
+                continue;
+
+            if(this._operators.isOperatorObject(value))
+            {
+                if('$eq' in value)
+                    base[key] = value.$eq;
 
-            if(typeof document._id === 'undefined')
                 continue;
+            }
+
+            base[key] = value;
+        }
+        return base;
+    }
 
-            if(given.has(document._id) || this._ids().has(document._id))
-                throw new Error(`Duplicate _id "${document._id}"`);
+    /**
+     * Applies an update to the matching documents
+     * @param object filter
+     * @param object update
+     * @param object options {upsert}
+     * @param boolean many
+     * @return object {matchedCount, modifiedCount, upsertedId}
+     */
+    _update(filter, update, options, many)
+    {
+        this._requireFilter(filter);
+        const helpers = this._updateHelpers();
+        const changes = [];
 
-            given.add(document._id);
+        // compute every new version first: one invalid update leaves all documents untouched
+        for(let i = 0; i < this._documents.length; i++)
+        {
+            const doc = this._documents[i];
+            if(!this._operators.matches(doc, filter))
+                continue;
+
+            const next = applyUpdate(doc._data, update, helpers);
+            this._validate(next);
+            changes.push({ index: i, previous: doc._data, next });
+            if(!many) break;
         }
 
-        const ids = documents.map(document => this.insertOne(document));
+        if(!changes.length && options.upsert)
+        {
+            const data = applyUpdate(this._upsertBase(filter), update, helpers);
+            const id = this._insertDocument(data);
+            this._emitChange('insert', { ids: [id], documents: [this._copy(this._documents.at(-1)._data)] });
+            return { matchedCount: 0, modifiedCount: 0, upsertedId: id };
+        }
 
-        if(typeof callback === 'function')
-            callback(ids);
+        const modified = changes.filter(change => JSON.stringify(change.previous) !== JSON.stringify(change.next));
+        for(const change of modified)
+            this._documents[change.index] = new documents(change.next);
 
-        return ids;
+        if(modified.length)
+        {
+            this._emitChange('update', {
+                ids: modified.map(change => change.next._id),
+                documents: modified.map(change => this._copy(change.next)),
+                previous: modified.map(change => this._copy(change.previous))
+            });
+        }
+
+        return { matchedCount: changes.length, modifiedCount: modified.length, upsertedId: null };
+    }
+
+    /**
+     * Updates the first matching document: updateOne({name: 'Ana'}, {$set: {age: 30}, $inc: {visits: 1}})
+     * Operators: $set, $unset, $inc, $push (with $each), $pull. The _id cannot change.
+     * @param object filter
+     * @param object update
+     * @param object options {upsert: insert when nothing matches}
+     * @return object {matchedCount, modifiedCount, upsertedId}
+     */
+    updateOne(filter, update, options = {})
+    {
+        return this._update(filter, update, options, false);
+    }
+
+    /**
+     * Updates every matching document, see updateOne()
+     * @param object filter
+     * @param object update
+     * @param object options {upsert}
+     * @return object {matchedCount, modifiedCount, upsertedId}
+     */
+    updateMany(filter, update, options = {})
+    {
+        return this._update(filter, update, options, true);
+    }
+
+    /**
+     * Replaces the first matching document, keeping its _id
+     * @param object filter
+     * @param object replacement a document without update operators
+     * @param object options {upsert}
+     * @return object {matchedCount, modifiedCount, upsertedId}
+     */
+    replaceOne(filter, replacement, options = {})
+    {
+        this._requireFilter(filter);
+        if(!this._isDocument(replacement))
+            throw new Error('The replacement must be a document');
+
+        if(Object.keys(replacement).some(key => key.startsWith('$')))
+            throw new Error('The replacement cannot contain update operators, use updateOne()');
+
+        if(!this._validateKeys(replacement))
+            throw new Error('Invalid document keys');
+
+        const index = this._documents.findIndex(doc => this._operators.matches(doc, filter));
+        if(index === -1)
+        {
+            if(!options.upsert)
+                return { matchedCount: 0, modifiedCount: 0, upsertedId: null };
+
+            const id = this._insertDocument(replacement);
+            this._emitChange('insert', { ids: [id], documents: [this._copy(this._documents.at(-1)._data)] });
+            return { matchedCount: 0, modifiedCount: 0, upsertedId: id };
+        }
+
+        const previous = this._documents[index]._data;
+        if(typeof replacement._id !== 'undefined' && replacement._id !== previous._id)
+            throw new Error('The _id field cannot be changed');
+
+        const next = { ...this._copy(replacement), _id: previous._id };
+        this._validate(next);
+        const modified = JSON.stringify(previous) !== JSON.stringify(next);
+        if(modified)
+        {
+            this._documents[index] = new documents(next);
+            this._emitChange('replace', { ids: [next._id], documents: [this._copy(next)], previous: [this._copy(previous)] });
+        }
+
+        return { matchedCount: 1, modifiedCount: modified ? 1 : 0, upsertedId: null };
+    }
+
+    /**
+     * Removes matching documents, keeping the documents array in place
+     * @param object filter
+     * @param boolean many
+     * @return object {deletedCount}
+     */
+    _delete(filter, many)
+    {
+        this._requireFilter(filter);
+        const removed = [];
+        let write = 0;
+        for(let read = 0; read < this._documents.length; read++)
+        {
+            const doc = this._documents[read];
+            if((many || !removed.length) && this._operators.matches(doc, filter))
+                removed.push(doc._data);
+            else
+                this._documents[write++] = doc;
+        }
+        this._documents.length = write;
+
+        if(removed.length)
+        {
+            for(const data of removed)
+                this._idSet?.delete(data._id);
+
+            this._emitChange('delete', { ids: removed.map(data => data._id), documents: removed });
+        }
+
+        return { deletedCount: removed.length };
+    }
+
+    /**
+     * Deletes the first matching document
+     * @param object filter
+     * @return object {deletedCount}
+     */
+    deleteOne(filter)
+    {
+        return this._delete(filter, false);
+    }
+
+    /**
+     * Deletes every matching document; deleteMany({}) empties the collection
+     * @param object filter
+     * @return object {deletedCount}
+     */
+    deleteMany(filter)
+    {
+        return this._delete(filter, true);
+    }
+
+    _requireFilter(filter)
+    {
+        if(!this._isDocument(filter))
+            throw new Error('The filter must be a query object, use {} to match every document');
     }
 
     //create index

package/src/query_language/operators.js

@@ -4,7 +4,7 @@ class operators {
      */
     constructor() {
         this._logicalOperators = ['$or', '$and', '$not', '$nor'];
-        this._comparisonOperators = ['$lt', '$lte', '$gt', '$gte', '$eq', '$ne', '$in', '$nin'];
+        this._comparisonOperators = ['$lt', '$lte', '$gt', '$gte', '$eq', '$ne', '$in', '$nin', '$exists', '$regex', '$options'];
     }
 
     /**
@@ -94,9 +94,15 @@ class operators {
      * @return boolean
      */
     matchesCondition(value, condition) {
+        if(this.isRegExp(condition))
+            return this.matchesRegex(value, condition);
+
         if(!this.isOperatorObject(condition))
             return this.$eq(value, condition);
 
+        if('$options' in condition && !('$regex' in condition))
+            throw new Error('The $options operator must be used with $regex');
+
         for(const operator of Object.keys(condition)) {
             if(operator === '$not') {
                 if(this.matchesCondition(value, condition[operator]))
@@ -105,6 +111,16 @@ class operators {
                 continue;
             }
 
+            if(operator === '$options')
+                continue;
+
+            if(operator === '$regex') {
+                if(!this.matchesRegex(value, this.toRegExp(condition.$regex, condition.$options)))
+                    return false;
+
+                continue;
+            }
+
             if(!this.isOperator(operator))
                 throw new Error(`Unknown operator ${operator}`);
 
@@ -115,6 +131,45 @@ class operators {
         return true;
     }
 
+    /**
+     * Whether a value is a RegExp (also from another realm: iframes, workers, vm contexts)
+     * @param mixed value
+     * @return boolean
+     */
+    isRegExp(value) {
+        return Object.prototype.toString.call(value) === '[object RegExp]';
+    }
+
+    /**
+     * Builds the RegExp of a $regex condition
+     * @param string|RegExp pattern
+     * @param string options i (case insensitive), m (multiline), s (dot matches new lines)
+     * @return RegExp
+     */
+    toRegExp(pattern, options = '') {
+        if(typeof options !== 'string' || /[^ims]/.test(options))
+            throw new Error('The $options operator accepts only the flags i, m and s');
+
+        if(this.isRegExp(pattern))
+            return new RegExp(pattern.source, [...new Set((pattern.flags + options).replace(/[gy]/g, ''))].join(''));
+
+        if(typeof pattern !== 'string')
+            throw new Error('The $regex operator must be a string or a RegExp');
+
+        return new RegExp(pattern, options);
+    }
+
+    /**
+     * Strings match when the pattern finds them, arrays when one of their strings does
+     * @param mixed value
+     * @param RegExp regex
+     * @return boolean
+     */
+    matchesRegex(value, regex) {
+        const test = item => typeof item === 'string' && (regex.lastIndex = 0, regex.test(item));
+        return Array.isArray(value) ? value.some(test) : test(value);
+    }
+
     /**
      * Whether a condition is an object made of operators, like {$gt: 5}
      * @param mixed condition
@@ -128,6 +183,16 @@ class operators {
         return keys.length > 0 && keys.every(key => key.startsWith('$'));
     }
 
+    /**
+     * Exists operator: {field: {$exists: true}} matches documents that have the field (even null)
+     * @param mixed doc_value
+     * @param boolean exists
+     * @return boolean
+     */
+    get $exists() {
+        return (doc_value, exists) => (doc_value !== undefined) === !!exists;
+    }
+
     /**
      * Not in operator
      * @param mixed doc_value

package/src/query_language/query.js

@@ -14,9 +14,13 @@ class query extends manipulation
      * Count documents
      * @return int
      */
-    count()
+    count(query)
     {
-        return this._documents.length;
+        if(typeof query === 'undefined')
+            return this._documents.length;
+
+        // counts without copying the documents
+        return this._documents.reduce((total, doc) => total + (this._operators.matches(doc, query) ? 1 : 0), 0);
     }
 
     /**