monkey-ldb 1.0.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ciberinuverse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MonkeyDB.js

@@ -0,0 +1,327 @@
+const fs = require("fs/promises")
+const monkey_document = require("./modules/native_documents.js")
+const monkey_utils = require("./modules/utils.js")
+
+async function read_document(name) {
+    let document_read = await fs.readFile(name)
+    return JSON.parse(document_read)
+}
+
+async function save_document(name, new_document_object) {
+    await fs.writeFile(name, JSON.stringify(new_document_object))
+}
+
+class MonkeyCli {
+
+    #document_cached = {
+        "time": 0,
+        "document": 0,
+    }
+
+    constructor(name, path_collections, use_cache = false) {
+        this.name = name
+
+        // Path collections es donde se almacenan todos los documentos
+        this.path_collections = monkey_utils.normalize_url(path_collections)
+        this.use_cache = use_cache
+
+        // Full path collection incluye el nombre de este documento con json
+        this.full_path_collection = this.path_collections + "/" + this.name + ".json"
+    }
+
+    async #cache_document() {
+        
+        let files_list = await fs.readdir(this.path_collections + "/")
+        
+        // Si no estamos en modo cache
+        if (!this.use_cache) {
+
+            // Se verifica que no exista el documento. Si no existe se retorna un false
+            if (!files_list.includes(this.name + ".json")) {
+                this.#document_cached["document"] = []
+                return false
+            }
+
+            // Si existe el documento, se lee y se retorna true
+            // guardando el contenido de el documento en una variable privada
+            this.#document_cached["document"] = await read_document(this.full_path_collection)
+            return true
+        }
+
+        let time_now = Date.now()
+
+        // Si el documento no existe dentro de la carpeta de la base de datos
+        if (!files_list.includes(this.name + ".json")) {
+            
+            // Se almacena de manera global un array vacio como tambien la hora
+            this.#document_cached["time"] = time_now
+            this.#document_cached["document"] = []
+
+            // Se guarad el documento vacio para evitar que siga un siclo
+            await save_document(this.full_path_collection, [])
+            
+            // Se retorna el array vacio indicando que no existe ningun documento asociado
+            return false
+        }
+
+        // Si el documento aun no esta cacheado se lee y se guarda y se retorna true
+        if (this.#document_cached["document"] === 0) {
+
+            this.#document_cached["time"] = time_now
+            this.#document_cached["document"] = await read_document(this.full_path_collection)
+
+            return true
+        }
+
+        // Se suman 5 minutos en ms al tiempo desde que se guardo el anterior estado
+        let time_cached = this.#document_cached["time"] + 3000
+        
+        // Si se superan los 5 minutos se actualiza el cacheado y se guarda en el documento
+        if (time_cached < time_now) {
+            this.#document_cached["time"] = time_now
+            await save_document(this.full_path_collection, this.#document_cached["document"])
+        }
+
+        // Se retorna el documento cacheado
+        return true
+    }
+
+    async find_one(object_find, object_project = null) {
+
+        // Se verifica la existencia del archivo o si existe cache
+        let exist_doc = await this.#cache_document()
+        if (!exist_doc) {return {}}
+
+        return monkey_document.iter_document_array(
+            object_find,
+            object_project,
+            this.#document_cached["document"],
+            "find_one"
+        )
+
+    }
+
+    async find(object_find, object_project = null) {
+        
+        // Se verifica la existencia del documento        
+        let exist_doc = await this.#cache_document()
+        if (!exist_doc) {return []}
+
+        return monkey_document.iter_document_array(object_find, object_project, this.#document_cached["document"], "find")
+
+    }
+
+    async insert_one(object_insert) {
+        await this.#cache_document()
+
+        let _id = object_insert["_id"] || monkey_utils.gen_uuid()
+
+        object_insert["_id"] = _id
+
+        // Se verifica la existencia del documento
+        this.#document_cached["document"].push(object_insert)
+        
+        // Si no se esta usando la forma de cache se guarda el documento
+        if (!this.use_cache) {
+            await save_document(this.full_path_collection, this.#document_cached["document"])
+        }
+
+        return monkey_utils.monkey_db_return({
+            "acknowledged": true,
+            "_id": _id,
+            "insertedCount": 1
+        })
+    }
+
+    async insert_many(array_insert) {
+        await this.#cache_document()
+
+        let insertedIds = []
+
+        for (let doc_one of array_insert) {
+            
+            // Se genera un id para el objeto a insertar
+            let _id = doc_one["_id"] || monkey_utils.gen_uuid()
+            
+            // Se le asigna el id
+            doc_one["_id"] = _id
+
+            // Se le asigna al buffer
+            this.#document_cached["document"].push(doc_one)
+            insertedIds.push(_id)
+
+        }
+
+        if (!insertedIds) {
+            return monkey_utils.monkey_db_return({
+                "acknowledged": false,
+                "insertedCount": 0,
+                "insertedIds": []
+            })
+        }
+
+        
+        if (!this.use_cache) {
+            await save_document(this.full_path_collection, this.#document_cached["document"])
+        }
+
+        return monkey_utils.monkey_db_return({
+            "acknowledged": true,
+            "insertedCount": insertedIds.length,
+            "insertedIds": insertedIds
+        })
+    }
+
+    async delete_one(object_find) {
+        await this.#cache_document()
+
+        let acknowledged = false
+    
+        let index_delete = monkey_document.iter_document_array(object_find, null, this.#document_cached["document"], "delete_one")
+        this.#document_cached["document"].splice(index_delete)
+    
+        if (!this.use_cache) {
+            await save_document(this.full_path_collection, this.#document_cached["document"])
+        }
+
+        return monkey_utils.monkey_db_return({
+            "acknowledged": true,
+            "deletedCount": 1,
+        })
+    }
+
+    async delete_many(object_find) {
+        await this.#cache_document()
+
+        let array_of_index_delete = await monkey_document.iter_document_array(object_find, null, this.#document_cached["document"], "delete_many")
+        
+        if (!array_of_index_delete) {
+            return monkey_utils.monkey_db_return({
+                "acknowledged": false,
+                "deletedCount": 0
+            })
+        }
+
+        for (let index_delete of array_of_index_delete) {
+            this.#document_cached["document"].splice(index_delete)
+        }
+        
+            
+        if (!this.use_cache) {
+            await save_document(this.full_path_collection, this.#document_cached["document"])
+        }
+
+        let deleted_account = array_of_index_delete.length
+        return monkey_utils.monkey_db_return({
+            "acknowledged": true,
+            "deletedCount": deleted_account
+        })
+
+    }
+
+    async update_one(object_find, mod_filter) {
+        await this.#cache_document()
+
+        
+        let response = await monkey_document.iter_document_array(object_find, mod_filter, this.#document_cached["document"], "update_one")
+        
+        let new_document = response[0]
+
+        if (!new_document) {return monkey_utils.monkey_db_return({
+            "acknowledged": false,
+            "matchedCount": 0,
+            "modifiedCount": 0
+        })}
+
+        let index_update = response[1]
+
+        this.#document_cached["document"][index_update] = new_document
+
+        if (!this.use_cache) {
+            await save_document(this.full_path_collection, this.#document_cached["document"])
+        }
+
+        return monkey_utils.monkey_db_return({
+            "acknowledged": true,
+            "matchedCount": 1,
+            "modifiedCount": 1
+        })
+
+    }
+
+    async update_many(object_find, mod_filter) {
+        await this.#cache_document()
+
+        
+        let response = await monkey_document.iter_document_array(object_find, mod_filter, this.#document_cached["document"], "update_many")
+
+        for (let doc_updated of response) {
+
+            let new_document = doc_updated[0]
+            let index_update = doc_updated[1]
+
+            this.#document_cached["document"][index_update] = new_document
+        
+        }
+
+        if (!this.use_cache) {
+            await save_document(this.full_path_collection, this.#document_cached["document"])
+        }
+
+        let mod_count = response.length
+        return monkey_utils.monkey_db_return({
+            "acknowledged": true,
+            "modifiedCount": mod_count,
+            "matchedCount": mod_count
+        })
+    }
+}
+
+class MonkeyDB {
+
+    #collections = []
+
+    constructor(name_db, path_db = ".", cache = false) {
+        this.name_db = name_db
+        this.path_db = monkey_utils.normalize_url(path_db)
+
+        this.cache = cache
+        this.uri = path_db + "/" + name_db
+    }
+
+    // Funcion privada encargada de verificar que la base de datos se encuentre en la carpeta
+    async #dir_db_exist() {
+        
+        let db_dir = await fs.readdir(this.path_db)
+        
+        // De no ser asi la crea
+        if (!db_dir.includes(this.name_db)) {
+            await fs.mkdir(this.name_db)
+        }
+
+        // Actualiza la lista de colecciones en la bd
+        this.#collections = await fs.readdir(this.uri + "/")
+    }
+
+    async create_collection(name_collection) {
+        // Verifica y crea la carpeta de la base de datos si es necesario
+        await this.#dir_db_exist()
+        
+        return new MonkeyCli(name_collection, this.uri, this.cache)
+    }
+
+    async drop_collection(name_collection) {
+        await this.#dir_db_exist()
+
+        if (!this.#collections.includes(name_collection + ".json")) {
+            return false
+        }
+
+        await fs.rm(this.uri + "/" + name_collection + ".json")
+        return true
+    }
+
+}
+
+// Se exporta unicamente MonkeyDB encargado de crear la base de datos
+module.exports = {MonkeyDB}

package/README.md

@@ -0,0 +1,112 @@
+# MonkeyDB
+
+> Una base de datos NoSQL local para Node.js, inspirada en MongoDB y construida con pura curiosidad y ganas de aprender.
+
+![Si no estoy durmiendo, estoy programando](assets/monkeydb.png)  
+*Si no estoy durmiendo, estoy programando.*
+
+MonkeyDB es una base de datos experimental que almacena datos en archivos JSON, diseñada para proyectos pequeños que necesitan una API familiar de MongoDB sin levantar un servidor externo. Nació como un ejercicio de aprendizaje y para cubrir una necesidad personal: quería una base de datos local y liviana que se sintiera como MongoDB, pero sin saber que ya existían varias alternativas consolidadas. Así que… ¿Por qué no construir la mía?
+
+## Características
+
+- **API inspirada en MongoDB** – usa métodos como `find()`, `insert_one()`, `insert_many()`.
+- **Almacenamiento local** – cada colección se guarda como un archivo JSON.
+- **Proyecciones** – puedes elegir qué campos devolver en las consultas (`{ "_id": 0 }`).
+- **Caché opcional** – mejora el rendimiento cuando trabajas con colecciones grandes.
+- **Manejo asíncrono** – basado en `fs/promises` para no bloquear el event loop.
+- **Multi‑colección** – agrupa tus datos en colecciones dentro de una misma base de datos.
+
+## Instalación
+
+*(Pendiente de publicación en npm)*
+
+## Uso básico
+
+```javascript
+const { MonkeyDB } = require('monkeydb');
+
+(async () => {
+  // Crear o abrir una base de datos
+  const db = new MonkeyDB('mi_app', './data', false);
+
+  // Crear una colección (automáticamente crea la carpeta si no existe)
+  const users = await db.create_collection('users');
+
+  // Insertar un documento
+  const result = await users.insert_one({ name: 'Ana', age: 28 });
+  console.log(result); // { acknowledged: true, _id: '...' }
+
+  // Insertar varios documentos
+  await users.insert_many([
+    { name: 'Luis', age: 34 },
+    { name: 'Elena', age: 25 }
+  ]);
+
+  // Buscar documentos con filtro y proyección
+  const ana = await users.find_one({ name: 'Ana' }, { _id: 0 });
+  console.log(ana); // { name: 'Ana', age: 28 }
+
+  const mayores = await users.find({ age: { $gt: 30 } }); // pronto operadores
+  console.log(mayores); // []
+})();
+```
+
+## API
+
+### `MonkeyDB(name_db, path_db, options)`
+- `name_db` – nombre de la base de datos (se usará como carpeta).
+- `path_db` – ruta donde se almacenará la carpeta de la base de datos (por defecto `"."`).
+- `cache` – habilita el sistema de caché experimental (por defecto `false`).
+
+### `db.create_collection(name_collection)`
+Crea una nueva colección (si no existe) y devuelve una instancia de `MonkeyCli`.
+
+### `collection.insert_one(document)`
+Inserta un documento y devuelve un objeto con `acknowledged` y el `_id` generado.
+
+### `collection.insert_many(array)`
+Inserta un array de documentos y devuelve `acknowledged`, `insertedCount` e `insertedIds`.
+
+### `collection.find(filter, projection)`
+Devuelve un array con todos los documentos que coinciden con el filtro.  
+`projection` permite excluir campos con `{ campo: 0 }`.
+
+### `collection.find_one(filter, projection)`
+Devuelve el primer documento que coincide con el filtro, o `{}` si no hay resultados.
+
+## Estado actual y roadmap
+
+MonkeyDB está en una fase **experimental**. Lo que ya funciona:
+
+- `create_collection`
+- `insert_one` / `insert_many`
+- `find` / `find_one` con proyecciones básicas (solo exclusión)
+- Operadores de consulta: `$gt`, `$lt`, `$in`, `$regex`, etc.
+- Actualizaciones: `update_one`, `update_many`
+- Eliminaciones: `delete_one`, `delete_many`
+- Caché funcional (actualmente en pruebas)
+- Uso asíncrono con `fs/promises`
+- Rutas configurables
+- Tests manuales
+
+Próximas mejoras (¡contribuciones bienvenidas!):
+
+- 🔄 Índices para mejorar búsquedas
+- 🔄 Migración hacia/desde otras bases de datos (MongoDB, SQLite, etc.)
+- 🔄 Tests unitarios y de integración
+
+## Módulos
+
+MonkeyDB está organizado en tres módulos internos que mantienen el código limpio y extensible:
+
+| Módulo | Archivo | Propósito |
+|--------|---------|-----------|
+| **Operadores de actualización** | `operators_update.js` | Contiene todas las funciones y utilidades para acciones de update: `$set`, `$unset`, `$rename`, `$max`, `$min`, `$currentDate`, `$push`, `$pull`, etc. Exporta como única utilidad la función `operators_update`. |
+| **Operadores de búsqueda** | `operators.js` | Implementa los operadores de consulta: `$ne`, `$nin`, `$in`, `$eq`, `$lt`, `$gt`, etc. Exporta como única función `operators_find`. |
+| **Utilidades** | `utils.js` | Funciones de mantenimiento y ayuda, como las respuestas uniformes de MonkeyDB (consistencia en los formatos de salida). |
+
+Estos módulos se integran en el archivo principal y permiten añadir nuevos operadores sin modificar la lógica central.
+
+## Agradecimientos
+
+Este proyecto está fuertemente inspirado en **MongitaDB**, una base de datos local que a su vez emula MongoDB. ¡Gracias a su creador por allanar el camino y sacarme de varios apuros mientras desarrollaba otros proyectos!

package/modules/native_documents.js

@@ -0,0 +1,98 @@
+const monkey_operators = require("./operators.js")
+const monkey_operators_update = require("./operators_update.js")
+
+let iters_with_index = ["delete_many", "delete_one", "update_one", "update_many"]
+function iter_document_array(object_find, object_project = null, array_document, type_r = "find") {
+
+    let return_doc = []
+    let index_list = 0 // Variable que se usara para todo lo que requiera indice de listas
+
+    
+    // Se establece el numero de coincidencias desde el objeto a buscar
+    let check = Object.values(object_find).length
+    
+
+
+    // Por cada documento encontrado se revisara que cumpla con el filtro enviado
+    for (let one_doc of array_document) {
+        
+        // Contador de coincidencias por usuario
+        let passed_check = 0
+
+        // Se setean las variables para usarle dentro del for
+        let key, value
+        
+        for ([key, value] of Object.entries(object_find)) {
+            if (monkey_operators.operators_find(one_doc, key, value)) {passed_check += 1}
+        }
+
+        /* Seccion unicamente para resultados unicos que no requieren mayor iteracion */
+        // Se usan else if al ser mas rapidos
+        if (type_r === "delete_one" && passed_check === check) {
+            return index_list
+        }
+
+        // Se retorna la primera coincidencia con la proyeccion si es que se esta pidiendo uno solo
+        else if (type_r === "find_one" && passed_check === check) {
+            return project(one_doc, object_project)
+        }
+
+        else if (type_r === "update_one" && passed_check === check) {
+            return [monkey_operators_update.operators_update(one_doc, object_project), index_list]
+        }
+
+        /* ===================================================================== */
+
+        /* Seccion operacion listado 
+        
+        Todo lo que esta aqui debajo hasta lo limitado son las operaciones que requieren de una iteracion
+        completa del documento. Tales como find, delete_many
+        
+        */
+
+        // Si se cumple con el filtro se agrega a la lista y se continua
+        else if (type_r === "find" && passed_check === check) {
+            return_doc.push(project(one_doc, object_project))
+            continue
+        }
+
+        // Zonas que requieren indices
+        else if (type_r === "delete_many" && passed_check === check) {
+            return_doc.push(index_list)
+        }
+
+        else if (type_r === "update_many" && passed_check === check) {
+            return_doc.push([monkey_operators_update.operators_update(one_doc, object_project), index_list])
+        }
+
+        if (iters_with_index.includes(type_r)) {index_list += 1}
+        
+    }
+
+    // Se retornan todos los documentos en la lista
+    return return_doc
+
+}
+
+function project(object_return, object_project = null) {
+    
+    // Si es que no se trae ninguna proyeccion se retorna el objeto intacto
+    if (object_project === null) {return object_return}
+
+    let key, value
+    for ([key, value] of Object.entries(object_project)) {
+
+        // Si se le asigno un false o un 0 se elimina esa key del object
+        if (!value) {
+            delete object_return[key]
+        }
+
+    }
+
+    // Se retorna el nuevo object
+    return object_return
+}
+
+module.exports = {
+    iter_document_array
+}

package/modules/operators.js

@@ -0,0 +1,73 @@
+function eq(one_doc_value, value_find) {return one_doc_value === value_find}
+function ne(one_doc_value, value_find) {return one_doc_value !== value_find}
+function gt(one_doc_value, value_find) {return one_doc_value > value_find}
+function gte(one_doc_value, value_find) {return one_doc_value >= value_find}
+function lt(one_doc_value, value_find) {return one_doc_value < value_find}
+function lte(one_doc_value, value_find) {return one_doc_value <= value_find}
+function in_d(one_doc_value, value_find) {return value_find.includes(one_doc_value)}
+function nin_d(one_doc_value, value_find) {return !value_find.includes(one_doc_value)}
+
+let operators = {
+    "$eq": eq,
+    "$ne": ne,
+    "$gt": gt,
+    "$gte": gte,
+    "$lt": lt,
+    "$lte": lte,
+    "$in": in_d,
+    "$nin": nin_d
+}
+
+
+function operators_find(one_doc, key_find, value_find) {
+
+    // Si se encuentra la coincidencia directa se retorna true
+    if (one_doc[key_find] === value_find) {return true}
+
+    // Si no es un objeto el que se envio es porque no contiene operadores por ende es falso
+    if (typeof value_find !== 'object') {return false} 
+
+    // Se obtiene la lista de operadores a trabajar
+    let operators_list_find = Object.keys(value_find)
+    
+    // Se verifica si es mas de uno. En caso de serlo se itera por cada operador enviando los resultados a un array
+    if (operators_list_find.length > 1) {
+        
+        let result_filter = []
+        for (let key_operator of operators_list_find) {
+
+            operator_function_execute = operators[key_operator]
+            if (!operator_function_execute) {
+                return false
+            }
+
+            result_filter.push(operator_function_execute(one_doc[key_find], value_find[key_operator]))
+        }
+
+        // Cuando se termina la iteracion, se verifica que el array contenga todas las respuestas como true.
+        return result_filter.every(x => x === true)
+
+    } 
+
+    // Value find es esto: {"$ne": "ola"}
+    let operator = operators_list_find[0] // Esto se transforma en $ne
+    let operator_value = value_find[operator] // Esto se transforma en 'ola'
+
+    let operator_in = operators[operator] // Operator in obtiene la funcion almacenada en el diccionario
+
+    // Si no existe un operador valido o no existe una funcion asociada, se retorna falso
+    if (!operator || !operator_in) {
+        return false
+    }
+    
+    // One doc value es el valor del documento tiene para comparar
+    let one_doc_value = one_doc[key_find]
+    
+    // Se pasan los dos parametros a comparar dependiendo del operador
+    return operator_in(one_doc_value, operator_value)
+
+}
+
+module.exports = {
+    operators_find
+}

package/modules/operators_update.js

@@ -0,0 +1,227 @@
+function set(document_object, list_modifications) {
+
+    let mods_list = Object.keys(list_modifications)
+
+    for (let key_dict_on_document of mods_list) {
+        document_object[key_dict_on_document] = list_modifications[key_dict_on_document]
+    }
+
+    return document_object
+
+}
+function unset(document_object, list_modifications) {
+
+    let mods_list = Object.keys(list_modifications)
+
+    for (let key_dict_on_document of mods_list) {
+        delete document_object[key_dict_on_document]
+    }
+
+    return document_object
+
+}
+
+function rename(document_object, list_modifications) {
+    let mods_list = Object.keys(list_modifications)
+
+
+    for (let key_dict_on_document of mods_list) {
+
+        let buff_doc, is_json
+        
+        // Se intenta copiar el contenido dentro del nombre de la variable
+        try {
+            buff_doc = JSON.stringify(document_object[key_dict_on_document])
+            is_json = true
+        }
+        catch {
+            buff_doc = document_object[key_dict_on_document]
+        }
+
+        // Se borra del diccionario original
+        delete document_object[key_dict_on_document]
+
+        // Se verifica que la funcion fue marcada como json
+        if (is_json === true) {
+            buff_doc = JSON.parse(buff_doc)
+        }
+
+        // Y se crea un nuevo objeto con el nombre ya cambiado con el mismo contenido
+        document_object[list_modifications[key_dict_on_document]] = buff_doc
+
+    }
+
+    return document_object
+}
+
+function inc(document_object, list_modifications) {
+
+    let mods_list = Object.keys(list_modifications)
+
+    for (let key_dict_on_document of mods_list) {
+        document_object[key_dict_on_document] += list_modifications[key_dict_on_document]
+    }
+
+    return document_object
+
+}
+
+function mul(document_object, list_modifications) {
+    let mods_list = Object.keys(list_modifications)
+
+    for (let key_dict_on_document of mods_list) {
+        document_object[key_dict_on_document] = document_object[key_dict_on_document] * list_modifications[key_dict_on_document]
+    }
+
+    return document_object
+}
+
+function currentDate(document_object, list_modifications) {
+    let mods_list = Object.keys(list_modifications)
+
+    for (let key_dict_on_document of mods_list) {
+        document_object[key_dict_on_document] = Date.now()
+    }
+
+    return document_object
+}
+
+function push_d(document_object, list_modifications) {
+    let mods_list = Object.keys(list_modifications)
+
+    for (let key_dict_on_document of mods_list) {
+        
+        let list_in_doc = document_object[key_dict_on_document]
+        if (!list_in_doc) {
+            document_object[key_dict_on_document] = [list_modifications[key_dict_on_document]]
+            continue
+        }
+
+        document_object[key_dict_on_document].push(list_modifications[key_dict_on_document])
+
+    }
+
+    return document_object
+}
+
+function pull_d(document_object, list_modifications) {
+    
+    let mods_list = Object.keys(list_modifications)
+
+    for (let key_dict_on_document of mods_list) {
+        
+        let list_in_doc = document_object[key_dict_on_document]
+        if (!list_in_doc) {
+            continue
+        }
+
+        document_object[key_dict_on_document] = document_object[key_dict_on_document].filter(x => x !== list_modifications[key_dict_on_document])
+
+    }
+
+    return document_object
+
+}
+
+function max(document_object, list_modifications) {
+    let mods_list = Object.keys(list_modifications)
+
+    for (let key_dict_on_document of mods_list) {
+
+        if (list_modifications[key_dict_on_document] > document_object[key_dict_on_document]) {
+            document_object[key_dict_on_document] = list_modifications[key_dict_on_document] 
+        }
+    }
+
+    return document_object
+}
+
+function min(document_object, list_modifications) {
+    let mods_list = Object.keys(list_modifications)
+
+    for (let key_dict_on_document of mods_list) {
+
+        if (list_modifications[key_dict_on_document] < document_object[key_dict_on_document]) {
+            document_object[key_dict_on_document] = list_modifications[key_dict_on_document] 
+        }
+    }
+
+    return document_object
+}
+
+function pop_d(document_object, list_modifications) {
+    let mods_list = Object.keys(list_modifications)
+
+    for (let key_dict_on_document of mods_list) {
+        
+        if (!document_object[key_dict_on_document]) {continue}
+                
+        let idx_max = document_object[key_dict_on_document].length
+
+        // Si la lista solo contiene un elemento, se evita el slice y se retorna directamente vacio
+        if (idx_max === 1) {
+            document_object[key_dict_on_document] = []
+            continue
+        }
+
+        // Si se desea borrar unicamente el ultimo valor, se borra xd
+        if (list_modifications[key_dict_on_document] === 1) {
+            document_object[key_dict_on_document].splice(idx_max - 1)
+            continue
+        }
+
+        // Splice 0, 1 se usa porque quiero eliminar el indice 0 y especifico unicamente un elemento
+        // a eliminar, o splice toma todo el array completo.
+        document_object[key_dict_on_document].splice(0, 1)
+
+    }
+
+    return document_object
+}
+
+let operators_update_dict = {
+    "$set": set,
+    "$unset": unset,
+    "$rename": rename,
+    "$inc": inc,
+    "$mul": mul,
+    "$max": max,
+    "$min": min,
+    "$currentDate": currentDate,
+    
+    "$push": push_d,
+    "$pop": pop_d,
+    "$pull": pull_d,
+}
+
+function operators_update(one_doc, operators_project) {
+    
+    let operators_updates = Object.keys(operators_project)
+
+
+    if (operators_updates.length > 1) {
+
+        for (let key_update of operators_updates) {
+            let function_execute = operators_update_dict[key_update]
+
+            if (!function_execute) {continue}
+            
+            one_doc = function_execute(one_doc, operators_project[key_update])
+        }
+
+        return one_doc
+    }
+
+    let function_execute = operators_update_dict[operators_updates[0]]
+
+    if (!function_execute) {return one_doc}
+
+    one_doc = function_execute(one_doc, operators_project[operators_updates[0]])
+
+    return one_doc
+
+}
+
+module.exports = {
+    operators_update
+}

package/modules/utils.js

@@ -0,0 +1,39 @@
+const crypto = require("crypto")
+
+function monkey_db_return({acknowledged, _id = null, insertedCount = null, insertedIds = null, matchedCount = null, modifiedCount = null, deletedCount = null}) {
+    
+    let return_vars = {
+        "acknowledged": acknowledged,
+        "_id": _id,
+        "insertedCount": insertedCount,
+
+        "matchedCount": matchedCount,
+        "modifiedCount": modifiedCount,
+        "insertedIds": insertedIds,
+        "deletedCount": deletedCount
+    }
+    
+    // Se itera cada clave valor de el diccionario y se eliminan los vacios
+    let key, value
+    for ([key, value] of Object.entries(return_vars)) {
+        if (value === null) {
+            delete return_vars[key]
+        }
+    }
+    console.log(return_vars)
+    return return_vars
+}
+
+function normalize_url(url = "") {
+    if (url.endsWith("/")) {return url.slice(0, -1)}
+    return url
+}
+
+function gen_uuid() {
+    let uuid = String(Date.now())
+    return crypto.createHash("md5").update(uuid).digest("hex")
+}
+
+module.exports = {
+    monkey_db_return, normalize_url, gen_uuid
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "monkey-ldb",
+  "version": "1.0.0",
+  "description": "> Una base de datos NoSQL local para Node.js, inspirada en MongoDB y construida con pura curiosidad y ganas de aprender.",
+  "main": "MonkeyDB.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ciberuniverse/MonkeyDB.git"
+  },
+  "keywords": [],
+  "author": "Hernan Miranda",
+  "license": "MIT",
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/ciberuniverse/MonkeyDB/issues"
+  },
+  "homepage": "https://github.com/ciberuniverse/MonkeyDB#readme"
+}